@hanzo/ui 8.27.60 → 8.27.61

package/dist/models/catalog.cjs

@@ -1,220 +1,349 @@
 "use strict";
-/**
- * @hanzo/ui/models — Model catalog data layer
- *
- * Pure, SSR-safe helpers shared by the unified ModelSelector. No React,
- * no browser globals — usable on the server, in edge runtimes, or the client.
- *
- * ModelCatalogEntry is the gateway/OpenAI-shaped record ({ id, owned_by, ... })
- * returned by `${baseUrl}/models`. It is intentionally distinct from the
- * registry-shaped ZenModelLike in ./types (which drives the marketing cards).
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESEARCH = void 0;
-exports.familyOf = familyOf;
-exports.groupModelsByFamily = groupModelsByFamily;
-exports.isChatModel = isChatModel;
-exports.filterChatModels = filterChatModels;
+exports.CAPABILITY_NAMES = exports.CLASS_NAMES = exports.FAMILIES = exports.RESEARCH = void 0;
+exports.withResearch = withResearch;
+exports.modelOf = modelOf;
+exports.parseModels = parseModels;
 exports.fetchModelCatalog = fetchModelCatalog;
+exports.makerOf = makerOf;
+exports.makerName = makerName;
+exports.modelName = modelName;
+exports.groupKey = groupKey;
+exports.groupLabel = groupLabel;
+exports.groupModels = groupModels;
+exports.capabilitiesOf = capabilitiesOf;
+exports.can = can;
+exports.matchesPaused = matchesPaused;
+exports.isPaused = isPaused;
+exports.matchesModel = matchesModel;
+exports.sortModels = sortModels;
+exports.formatContext = formatContext;
+exports.formatPrice = formatPrice;
 /**
  * The models that exist and cannot be called, said once for every list of
  * models: a picker draws each one disabled, a catalogue page draws it muted.
- *
- * No gateway serves them, and that is the point: `/v1/models` never answers for
- * one, so nothing can route to it. A host that lists them appends these to what
- * the gateway said.
+ * `/v1/models` never answers for one, so nothing can route to it.
  */
 exports.RESEARCH = [
     {
         id: 'zen7',
         owned_by: 'zenlm',
-        label: 'Zen 7',
+        family: 'zen',
+        name: 'Zen 7',
         access: 'research',
         request: 'https://hanzo.ai/research-access',
         description: 'The next open-weight generation after Zen 6, in research preview.',
     },
 ];
+/** The catalog with the research models it does not already list, appended. */
+function withResearch(models) {
+    const ids = new Set(models.map((m) => m.id));
+    return [...models, ...exports.RESEARCH.filter((m) => !ids.has(m.id))];
+}
+// ── reading the wire ─────────────────────────────────────────────────────────
+const CLASSES = ['premium', 'ours', 'free'];
+const FAMILY_IDS = ['enso', 'zen', 'kai', 'jev', 'zoo'];
+const str = (v) => (typeof v === 'string' && v.trim() ? v : undefined);
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+const pos = (v) => {
+    const n = num(v);
+    return n !== undefined && n > 0 ? n : undefined;
+};
+const yes = (v) => (v === true ? true : undefined);
+const strs = (v) => {
+    if (!Array.isArray(v))
+        return undefined;
+    const out = v.filter((x) => typeof x === 'string' && x.trim() !== '').map((x) => x.toLowerCase());
+    return out.length ? out : undefined;
+};
+const oneOf = (set, v) => typeof v === 'string' && set.includes(v) ? v : undefined;
+function pricingOf(v) {
+    if (!v || typeof v !== 'object')
+        return undefined;
+    const p = v;
+    const input = num(p.input_per_million);
+    const output = num(p.output_per_million);
+    if (input === undefined && output === undefined)
+        return undefined;
+    return {
+        ...(input !== undefined && input >= 0 ? { input_per_million: input } : {}),
+        ...(output !== undefined && output >= 0 ? { output_per_million: output } : {}),
+    };
+}
+/** One row, checked field by field: it is a network response. Null without an id. */
+function modelOf(v) {
+    if (!v || typeof v !== 'object')
+        return null;
+    const r = v;
+    const id = str(r.id);
+    if (!id)
+        return null;
+    const m = { id };
+    const set = (k, val) => {
+        if (val !== undefined)
+            m[k] = val;
+    };
+    set('owned_by', str(r.owned_by));
+    set('name', str(r.name));
+    set('description', str(r.description));
+    set('class', oneOf(CLASSES, r.class));
+    set('family', oneOf(FAMILY_IDS, r.family));
+    set('premium', typeof r.premium === 'boolean' ? r.premium : undefined);
+    set('created', pos(r.created));
+    set('context_window', pos(r.context_window));
+    set('max_output_tokens', pos(r.max_output_tokens));
+    set('inputs', strs(r.inputs));
+    set('outputs', strs(r.outputs));
+    set('supports_vision', yes(r.supports_vision));
+    set('supports_tools', yes(r.supports_tools));
+    set('supports_reasoning', yes(r.supports_reasoning));
+    set('pricing', pricingOf(r.pricing));
+    return m;
+}
 /**
- * owned_by → display family.
- *
- * There is no `hanzo` entry, and its absence is the point. It used to say
- * `hanzo: 'Zen'`, which was wrong twice: Zoo Labs Foundation makes Zen, and the
- * gateway does not report Zen that way — it answers `owned_by: 'zenlm'`. What
- * `owned_by: 'hanzo'` actually names is the dozen models Hanzo serves under its
- * own namespace, so that entry filed Whisper, Kokoro, GLM, Kimi, Qwen3.5 and
- * MiniMax under "Zen" as well. Without it each falls to its id prefix and lands
- * where it belongs, and what is genuinely Hanzo's capitalizes to "Hanzo".
+ * The catalog from a `/v1/models` body (`{data: [...]}`) or its `data` array.
+ * Rows without an id are dropped; a repeated id keeps its first row.
  */
-const OWNER_FAMILY = {
-    zenlm: 'Zen',
+function parseModels(body) {
+    const rows = Array.isArray(body)
+        ? body
+        : body && typeof body === 'object' && Array.isArray(body.data)
+            ? (body.data)
+            : [];
+    const seen = new Set();
+    const out = [];
+    for (const row of rows) {
+        const m = modelOf(row);
+        if (!m || seen.has(m.id))
+            continue;
+        seen.add(m.id);
+        out.push(m);
+    }
+    return out;
+}
+/**
+ * Fetch the catalog from an OpenAI-shaped `/models` endpoint. No caching, no
+ * state: the host owns both. Throws on a non-2xx answer.
+ */
+async function fetchModelCatalog(baseUrl, token) {
+    const base = (baseUrl ?? 'https://api.hanzo.ai/v1').replace(/\/+$/, '');
+    const headers = { Accept: 'application/json' };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const res = await fetch(`${base}/models`, { headers });
+    if (!res.ok)
+        throw new Error(`fetchModelCatalog: ${res.status} ${res.statusText}`);
+    return parseModels(await res.json());
+}
+// ── what a model is ──────────────────────────────────────────────────────────
+/** The families, in the order every surface leads with them. */
+exports.FAMILIES = [
+    { id: 'enso', label: 'Enso' },
+    { id: 'zen', label: 'Zen' },
+    { id: 'kai', label: 'Kai' },
+    { id: 'jev', label: 'Jev' },
+    { id: 'zoo', label: 'Zoo' },
+];
+exports.CLASS_NAMES = {
+    premium: 'Premium',
+    ours: 'Hanzo',
+    free: 'Free',
+};
+/** The makers whose name is not their id capitalized. */
+const MAKERS = {
+    'aion-labs': 'Aion Labs',
+    'arcee-ai': 'Arcee AI',
+    'bytedance-seed': 'ByteDance Seed',
+    'dots-studio': 'dots.studio',
+    'ibm-granite': 'IBM Granite',
+    'inference-net': 'Inference.net',
+    'meta-llama': 'Meta Llama',
+    'nex-agi': 'Nex AGI',
+    'prism-ml': 'Prism ML',
+    'x-ai': 'xAI',
+    'z-ai': 'Z.ai',
+    ai21: 'AI21',
     anthropic: 'Anthropic',
-    openai: 'OpenAI',
+    bytedance: 'ByteDance',
+    cognitivecomputations: 'Cognitive Computations',
     deepseek: 'DeepSeek',
-    alibaba: 'Qwen',
-    qwen: 'Qwen',
-    meta: 'Meta Llama',
-    mistralai: 'Mistral',
-    mistral: 'Mistral',
-    google: 'Google Gemma',
+    inclusionai: 'inclusionAI',
+    minimax: 'MiniMax',
+    mistralai: 'Mistral AI',
+    moonshotai: 'Moonshot AI',
+    nousresearch: 'Nous Research',
     nvidia: 'NVIDIA',
-    moonshot: 'Kimi',
+    openai: 'OpenAI',
+    openrouter: 'OpenRouter',
+    rekaai: 'Reka AI',
+    thedrummer: 'TheDrummer',
+    thinkingmachines: 'Thinking Machines',
+    typesafe: 'TypeSafe',
+    zenlm: 'Zen LM',
 };
-/** What the picker leads with; everything else sorts alphabetically after these. */
-const FAMILY_ORDER = ['Enso', 'Zen', 'Anthropic', 'OpenAI'];
-function capitalize(s) {
-    return s ? s.charAt(0).toUpperCase() + s.slice(1) : s;
-}
-/** Infer a family from an id prefix. Returns undefined when nothing matches. */
-function familyFromId(id) {
-    if (id.startsWith('enso'))
-        return 'Enso';
-    if (id.startsWith('zen'))
-        return 'Zen';
-    if (id.startsWith('claude'))
-        return 'Anthropic';
-    if (id.startsWith('gpt') || id === 'o1' || id.startsWith('o1-') || id.startsWith('o3'))
-        return 'OpenAI';
-    if (id.startsWith('qwen'))
-        return 'Qwen';
-    if (id.startsWith('llama'))
-        return 'Meta Llama';
-    if (id.startsWith('glm'))
-        return 'GLM';
-    if (id.startsWith('kimi'))
-        return 'Kimi';
-    if (id.startsWith('deepseek'))
-        return 'DeepSeek';
-    if (id.startsWith('mistral'))
-        return 'Mistral';
-    if (id.startsWith('gemma'))
-        return 'Google Gemma';
-    if (id.startsWith('nemotron'))
-        return 'NVIDIA';
-    if (id.startsWith('minimax'))
-        return 'MiniMax';
-    if (id.startsWith('mimo'))
-        return 'MiMo';
-    return undefined;
+/** Who made a model, as the catalog keys it: `owned_by`, lowercased, without OpenRouter's `~` alias mark. */
+function makerOf(m) {
+    return (m.owned_by ?? '').trim().replace(/^~/, '').toLowerCase() || 'other';
+}
+/** A maker's display name. */
+function makerName(maker) {
+    return (MAKERS[maker] ??
+        maker
+            .split(/[-_]/)
+            .filter(Boolean)
+            .map((w) => w[0].toUpperCase() + w.slice(1))
+            .join(' '));
+}
+/** The name a model is shown by: the catalog's name, else its id. */
+function modelName(m) {
+    return m.name ?? m.id;
+}
+function groupKey(m) {
+    return m.family ? `family:${m.family}` : `maker:${makerOf(m)}`;
+}
+function groupLabel(m) {
+    const f = m.family && exports.FAMILIES.find((x) => x.id === m.family);
+    return f ? f.label : makerName(makerOf(m));
 }
 /**
- * Resolve the display family of a model.
- * Precedence: explicit `family` → enso id (house split, beats owned_by) →
- * owned_by map → llama id under any owner → capitalized owned_by → id prefix → "Other".
+ * Models in groups: Hanzo's families first, in FAMILIES order, then every maker
+ * by name. Models keep the order they came in, so the caller sorts first.
  */
-function familyOf(m) {
-    const explicit = m.family?.trim();
-    if (explicit)
-        return explicit;
-    const id = (m.id ?? '').toLowerCase();
-    // Enso ids form their own house family regardless of owned_by.
-    if (id.startsWith('enso'))
-        return 'Enso';
-    const owned = m.owned_by?.toLowerCase().trim();
-    if (owned) {
-        const byOwner = OWNER_FAMILY[owned];
-        if (byOwner)
-            return byOwner;
-        // llama* ids resolve to Meta Llama even under a different owner.
-        const byId = familyFromId(id);
-        if (byId)
-            return byId;
-        return capitalize(owned);
-    }
-    return familyFromId(id) ?? 'Other';
-}
-function orderFamilies(a, b) {
-    const ia = FAMILY_ORDER.indexOf(a);
-    const ib = FAMILY_ORDER.indexOf(b);
-    if (ia !== -1 || ib !== -1) {
-        if (ia === -1)
-            return 1;
-        if (ib === -1)
-            return -1;
-        return ia - ib;
+function groupModels(models) {
+    const groups = new Map();
+    for (const m of models) {
+        const key = groupKey(m);
+        let g = groups.get(key);
+        if (!g) {
+            g = { key, label: groupLabel(m), ...(m.family ? { family: m.family } : {}), models: [] };
+            groups.set(key, g);
+        }
+        g.models.push(m);
     }
-    return a.localeCompare(b);
+    const rank = (g) => (g.family ? exports.FAMILIES.findIndex((f) => f.id === g.family) : exports.FAMILIES.length);
+    return [...groups.values()].sort((a, b) => rank(a) - rank(b) || a.label.localeCompare(b.label));
 }
+const has = (list, ...want) => !!list && want.some((w) => list.includes(w));
 /**
- * Group models by family, ordered house-then-marquee-then-alphabetical.
- * Model order within each family is the input order (stable).
+ * What a model can do, read from what it publishes. A model that names no
+ * outputs is read as a text model, the way the gateway serves it.
  */
-function groupModelsByFamily(models) {
-    const byFamily = new Map();
-    for (const m of models) {
-        const fam = familyOf(m);
-        const arr = byFamily.get(fam);
-        if (arr)
-            arr.push(m);
-        else
-            byFamily.set(fam, [m]);
+function capabilitiesOf(m) {
+    const out = [];
+    const embeddings = has(m.outputs, 'embeddings', 'embedding');
+    const rerank = has(m.outputs, 'rerank');
+    const decision = has(m.outputs, 'decision');
+    const text = !m.outputs || has(m.outputs, 'text');
+    if (text && !embeddings && !rerank && !decision)
+        out.push('chat');
+    if (m.supports_vision || has(m.inputs, 'image'))
+        out.push('vision');
+    if (embeddings)
+        out.push('embeddings');
+    if (rerank)
+        out.push('rerank');
+    if (has(m.outputs, 'image'))
+        out.push('image');
+    if (has(m.outputs, 'video'))
+        out.push('video');
+    if (has(m.outputs, 'audio', 'transcript') || has(m.inputs, 'audio'))
+        out.push('audio');
+    if (decision)
+        out.push('decision');
+    if (m.supports_tools)
+        out.push('tools');
+    if (m.supports_reasoning)
+        out.push('reasoning');
+    return out;
+}
+function can(m, c) {
+    return capabilitiesOf(m).includes(c);
+}
+exports.CAPABILITY_NAMES = {
+    chat: 'Chat',
+    vision: 'Vision',
+    embeddings: 'Embeddings',
+    rerank: 'Rerank',
+    image: 'Image',
+    video: 'Video',
+    audio: 'Audio',
+    decision: 'Decision',
+    tools: 'Tools',
+    reasoning: 'Reasoning',
+};
+/** Whether `id` matches a paused entry: the same id, or a glob whose `*` stands for any run of characters. */
+function matchesPaused(id, pattern) {
+    if (!pattern.includes('*'))
+        return id === pattern;
+    const parts = pattern.split('*');
+    if (!id.startsWith(parts[0]) || !id.endsWith(parts.at(-1)))
+        return false;
+    let at = parts[0].length;
+    const end = id.length - parts.at(-1).length;
+    for (const part of parts.slice(1, -1)) {
+        const i = id.indexOf(part, at);
+        if (i < 0 || i + part.length > end)
+            return false;
+        at = i + part.length;
     }
-    return Array.from(byFamily.keys())
-        .sort(orderFamilies)
-        .map((family) => ({ family, models: byFamily.get(family) }));
-}
-/** Modality/id keywords that mark a model as NOT chat-capable. */
-const NON_CHAT = [
-    'embedding',
-    'embed',
-    'image',
-    'video',
-    'music',
-    'voice',
-    'tts',
-    'rerank',
-    'guard',
-    'foley',
-    'moderation',
-    'router',
-];
+    return at <= end;
+}
 /**
- * True when a model can be used for chat. Excludes embedding/image/video/
- * music/voice/tts/rerank/guard/foley/moderation/router by explicit modality
- * or by an id-segment heuristic.
+ * Whether the payer's plan has paused this model: its whole class is limited,
+ * or an entry in `paused` names it. It is still listed and still picked; the
+ * gateway refuses it or answers from Enso.
  */
-function isChatModel(m) {
-    const modality = (m.modality ?? '').toLowerCase().trim();
-    if (modality && NON_CHAT.some((k) => modality.includes(k)))
-        return false;
-    const id = (m.id ?? '').toLowerCase();
-    if (NON_CHAT.some((k) => id.includes(k)))
+function isPaused(m, limits) {
+    if (!limits)
         return false;
-    return true;
+    if (m.class && limits.classes[m.class]?.state === 'limited')
+        return true;
+    return !!limits.paused?.some((p) => matchesPaused(m.id, p.model));
 }
-/** Keep only chat-capable models. */
-function filterChatModels(models) {
-    return models.filter(isChatModel);
+/** Case-insensitive search: every word of the query appears in the model's id, name, maker, group or description. */
+function matchesModel(m, query) {
+    const words = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+    if (!words.length)
+        return true;
+    const hay = [m.id, m.name, makerOf(m), makerName(makerOf(m)), groupLabel(m), m.description]
+        .filter(Boolean)
+        .join(' ')
+        .toLowerCase();
+    return words.every((w) => hay.includes(w));
 }
-/**
- * Fetch a model catalog from an OpenAI-shaped `/models` endpoint.
- * SSR-safe: uses global fetch, no browser globals, no caching/state —
- * consumers own caching. Throws on a non-2xx response.
- */
-async function fetchModelCatalog(baseUrl, token) {
-    const base = (baseUrl ?? 'https://api.hanzo.ai/v1').replace(/\/+$/, '');
-    const headers = { Accept: 'application/json' };
-    if (token)
-        headers.Authorization = `Bearer ${token}`;
-    const res = await fetch(`${base}/models`, { headers });
-    if (!res.ok) {
-        throw new Error(`fetchModelCatalog: ${res.status} ${res.statusText}`);
-    }
-    const json = await res.json();
-    const rows = Array.isArray(json)
-        ? json
-        : Array.isArray(json?.data)
-            ? json.data
-            : [];
-    return rows
-        .map((d) => ({
-        id: String(d.id),
-        owned_by: d.owned_by ?? d.ownedBy ?? undefined,
-        family: d.family ?? undefined,
-        label: d.label ?? d.name ?? undefined,
-        premium: d.premium ?? undefined,
-        modality: d.modality ?? undefined,
-        context_window: d.context_window ?? d.contextWindow ?? d.context ?? undefined,
-        description: d.description ?? undefined,
-    }))
-        .filter((m) => m.id && m.id !== 'undefined');
+/** A sorted copy. Context and price put models without the figure last. */
+function sortModels(models, by = 'name') {
+    const name = (a, b) => modelName(a).localeCompare(modelName(b));
+    const last = (v, dir) => (v === undefined ? Infinity : dir * v);
+    return [...models].sort((a, b) => {
+        switch (by) {
+            case 'newest':
+                return (b.created ?? 0) - (a.created ?? 0) || name(a, b);
+            case 'context':
+                return last(a.context_window, -1) - last(b.context_window, -1) || name(a, b);
+            case 'price':
+                return last(a.pricing?.input_per_million, 1) - last(b.pricing?.input_per_million, 1) || name(a, b);
+            default:
+                return name(a, b);
+        }
+    });
+}
+// ── how a figure reads ───────────────────────────────────────────────────────
+/** "200K", "1M", "1.5M"; "" when the catalog states no window. */
+function formatContext(n) {
+    if (!n)
+        return '';
+    if (n >= 1_000_000)
+        return `${+(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1000)
+        return `${Math.round(n / 1000)}K`;
+    return String(n);
+}
+/** "$3.00" per 1M tokens, "Free" at zero, "" when the catalog lists no price. */
+function formatPrice(n) {
+    if (n === undefined)
+        return '';
+    if (n === 0)
+        return 'Free';
+    return n < 0.01 ? `$${+n.toPrecision(2)}` : `$${n.toFixed(2)}`;
 }