dsh-newapi-provider 0.0.0-stage → 0.8.4

package/lib/adapter.js

@@ -0,0 +1,191 @@
+/**
+ * LLM adapter for the New API gateway route.
+ *
+ * Wire protocols are served by the pi-ai SDK that DeepSeek Harness itself
+ * ships; the harness ↔ pi-ai conversion is delegated to the official
+ * `PiAiAdapter` from `@deepseek-ai/dsh-llm-pi-ai`, so message history,
+ * replay state, image handling and error classification stay identical to the
+ * built-in providers and follow DSH upgrades automatically.
+ *
+ * This module only turns the gateway catalog into one pi-ai provider profile
+ * per refresh, and answers model metadata from the catalog (context window,
+ * output cap, modalities, reasoning) with user overrides applied.
+ */
+import { LlmAdapter, LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { PiAiAdapter } from '@deepseek-ai/dsh-llm-pi-ai';
+import { createProvider } from '@earendil-works/pi-ai';
+import { openAICompletionsApi } from '@earendil-works/pi-ai/api/openai-completions.lazy';
+import { openAIResponsesApi } from '@earendil-works/pi-ai/api/openai-responses.lazy';
+import { anthropicMessagesApi } from '@earendil-works/pi-ai/api/anthropic-messages.lazy';
+import { googleGenerativeAIApi } from '@earendil-works/pi-ai/api/google-generative-ai.lazy';
+import { chatModels, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS } from './catalog.js';
+import { gatewayRoot, openaiBase } from './util.js';
+
+const ENDPOINT_TO_API = {
+  'openai-response': 'openai-responses',
+  anthropic: 'anthropic-messages',
+  openai: 'openai-completions',
+  gemini: 'google-generative-ai',
+};
+export const DEFAULT_ENDPOINT_PRIORITY = ['openai', 'anthropic', 'openai-response', 'gemini'];
+const LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+
+export function pickApi(endpointTypes, priority = DEFAULT_ENDPOINT_PRIORITY) {
+  const advertised = endpointTypes?.length ? endpointTypes : ['openai'];
+  for (const t of priority) if (advertised.includes(t) && ENDPOINT_TO_API[t]) return ENDPOINT_TO_API[t];
+  for (const t of advertised) if (ENDPOINT_TO_API[t]) return ENDPOINT_TO_API[t];
+  return 'openai-completions';
+}
+
+function baseUrlFor(baseURL, api) {
+  return api === 'openai-completions' || api === 'openai-responses' ? openaiBase(baseURL) : gatewayRoot(baseURL);
+}
+
+/** Reasoning level map: explicit override levels, else "reasoning on" defaults. */
+function thinkingLevelMap(entry) {
+  if (!entry.reasoning) return undefined;
+  if (!entry.reasoningLevels?.length) return undefined;
+  const allowed = new Set(entry.reasoningLevels);
+  return Object.fromEntries(LEVELS.map((l) => [l, allowed.has(l) ? l : null]));
+}
+
+export function toPiModel(entry, conn, priority) {
+  const api = pickApi(entry.endpointTypes, priority);
+  const levels = thinkingLevelMap(entry);
+  return {
+    id: entry.id,
+    name: entry.name,
+    api,
+    provider: conn.providerId,
+    baseUrl: baseUrlFor(conn.baseURL, api),
+    reasoning: Boolean(entry.reasoning),
+    input: entry.input.filter((m) => m === 'text' || m === 'image'),
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: entry.contextWindow ?? conn.defaultContextWindow ?? DEFAULT_CONTEXT_WINDOW,
+    maxTokens: entry.maxTokens ?? conn.defaultMaxTokens ?? DEFAULT_MAX_TOKENS,
+    ...(levels ? { thinkingLevelMap: levels } : {}),
+  };
+}
+
+/**
+ * Override only the serialized request. Native model/history identities stay
+ * local, preserving same-model replay signatures and prepared-call snapshots.
+ * All four SDK protocols invoke onPayload after serialization; streamSimple
+ * forwards it through buildBaseOptions. No history copying/traversal is added.
+ */
+export function withUpstreamModels(api, mapping) {
+  const wrap = (method) => (model, context, options) => {
+    const upstreamModel = mapping.get(model.id);
+    if (!upstreamModel || upstreamModel === model.id) return api[method](model, context, options);
+    return api[method](model, context, {
+      ...options,
+      onPayload: async (payload, nativeModel) => {
+        const next = await options?.onPayload?.(payload, nativeModel);
+        return { ...(next ?? payload), model: upstreamModel };
+      },
+    });
+  };
+  return { ...api, stream: wrap('stream'), streamSimple: wrap('streamSimple') };
+}
+
+function piProviderFor(conn, models, entries) {
+  const mapping = new Map(entries.map((e) => [e.id, e.upstreamModel || e.id]));
+  return createProvider({
+    id: conn.providerId,
+    name: conn.displayName,
+    baseUrl: openaiBase(conn.baseURL),
+    auth: {
+      apiKey: {
+        name: conn.displayName,
+        resolve: ({ credential }) => Promise.resolve({
+          auth: credential?.key === undefined ? {} : { apiKey: credential.key },
+          source: conn.displayName,
+        }),
+      },
+    },
+    models,
+    api: {
+      'openai-completions': withUpstreamModels(openAICompletionsApi(), mapping),
+      'openai-responses': withUpstreamModels(openAIResponsesApi(), mapping),
+      'anthropic-messages': withUpstreamModels(anthropicMessagesApi(), mapping),
+      'google-generative-ai': withUpstreamModels(googleGenerativeAIApi(), mapping),
+    },
+  });
+}
+
+/**
+ * The adapter registered for the `newapi` route. It owns catalog-driven
+ * metadata and delegates streaming to an inner PiAiAdapter that reads one
+ * immutable profile map per catalog generation.
+ */
+export class NewApiAdapter extends LlmAdapter {
+  constructor(host) { super(); this.host = host; }
+
+  providerInfo(provider) { return { id: provider, name: this.host.connection().displayName }; }
+  providerRetryPolicy() { return this.host.connection().retryPolicy; }
+
+  /** Each operation owns an immutable profile and key, including prepared streams. */
+  async bind(signal) {
+    const bound = this.host.capture();
+    const conn = bound.connection;
+    const apiKey = await bound.requireApiKey();
+    const catalog = await bound.catalog({ signal });
+    const entries = chatModels(catalog);
+    const profile = {
+      provider: conn.providerId, displayName: conn.displayName, apiKeyEnv: conn.apiKeyRef,
+      headers: conn.headers, streamIdleTimeoutMs: conn.streamIdleTimeoutMs,
+      maxRequestImageBytes: 20 * 1024 * 1024, requestImagePixelBudget: 2048 * 2048,
+      requestImageMaxBytes: 1024 * 1024, retryPolicy: conn.retryPolicy,
+      configuredMaxTokens: new Map(entries.filter((e) => e.source.overridden.includes('maxTokens')).map((e) => [e.id, e.maxTokens])),
+      modelErrors: new Map(),
+      piProvider: piProviderFor(conn, entries.map((e) => toPiModel(e, conn, conn.endpointPriority)), entries),
+    };
+    const profiles = new Map([[conn.providerId, profile]]);
+    const inner = new PiAiAdapter({
+      profiles: () => profiles,
+      resolveApiKey: async () => apiKey,
+      auth: this.host.piAuth,
+      resolveAttachments: this.host.resolveAttachments,
+      resolveImageAccess: this.host.resolveImageAccess,
+      onReplayDegrade: ({ model, reason }) => this.host.logger?.warn?.(`newapi-provider: replay degraded for ${model}: ${reason}`),
+    });
+    return { inner, catalog };
+  }
+
+  async listModels(provider) {
+    const bound = this.host.capture();
+    let catalog;
+    try { catalog = await bound.catalog(); }
+    catch (error) { this.host.reportError('catalog', error); return []; }
+    return chatModels(catalog).map((e) => ({ provider, id: e.id, name: e.name, inputModalities: e.input.filter((m) => m === 'text' || m === 'image') }));
+  }
+
+  async modelInfo(bound, provider, model, signal) {
+    const info = await bound.inner.resolveModel(provider, model, signal);
+    const entry = bound.catalog.entries.find((e) => e.id === model);
+    if (entry?.reasoningLevels?.length) info.reasoning = {
+      efforts: entry.reasoningLevels.map((l) => ({ id: ReasoningEffortId(l), name: l.charAt(0).toUpperCase() + l.slice(1) })),
+    };
+    if (entry?.maxTokens) info.defaultMaxTokens = entry.maxTokens;
+    return info;
+  }
+
+  async resolveModel(provider, model, signal) {
+    return this.modelInfo(await this.bind(signal), provider, model, signal);
+  }
+
+  async prepareCall(provider, model, signal) {
+    const bound = await this.bind(signal);
+    const prepared = await bound.inner.prepareCall(provider, model, signal);
+    const resolved = await this.modelInfo(bound, provider, model, signal);
+    return { model: resolved, stream: (options) => prepared.stream(options) };
+  }
+
+  async *stream(options) {
+    const bound = await this.bind(options.signal);
+    if (!chatModels(bound.catalog).some((e) => e.id === options.model)) {
+      throw new LlmError(`New API gateway has no chat model "${options.model}"`, 'UNKNOWN_MODEL');
+    }
+    yield* bound.inner.stream(options);
+  }
+}

package/lib/balance.js

@@ -0,0 +1,121 @@
+/**
+ * Balance and quota for the configured New API token.
+ *
+ * GET /api/status        (no auth)  → quota_per_unit, quota_display_type, usd_exchange_rate, custom currency
+ * GET /api/usage/token/  (token)    → token quota; `user_quota` too when the token allows user-quota queries
+ *
+ * Conversion mirrors New API's own billing controller: USD = quota / quota_per_unit,
+ * CNY = USD × usd_exchange_rate, TOKENS = raw quota. `price` (top-up unit price)
+ * is not an exchange rate and is never used.
+ */
+import { fetchJson, gatewayRoot, GatewayError } from './util.js';
+
+const DEFAULT_QUOTA_PER_UNIT = 500_000;
+
+export function displayOf(status) {
+  const perUnit = Number(status?.quota_per_unit) > 0 ? Number(status.quota_per_unit) : DEFAULT_QUOTA_PER_UNIT;
+  const type = String(status?.quota_display_type ?? (status?.display_in_currency === false ? 'TOKENS' : 'USD')).toUpperCase();
+  const rate = Number(status?.usd_exchange_rate) > 0 ? Number(status.usd_exchange_rate) : 7.3;
+  if (type === 'CNY') return { unit: 'CNY', symbol: '¥', factor: rate / perUnit, perUnit, estimated: status === undefined };
+  if (type === 'TOKENS') return { unit: 'TOKENS', symbol: '', factor: 1, perUnit, estimated: status === undefined };
+  if (type === 'CUSTOM') {
+    const customRate = Number(status?.custom_currency_exchange_rate) > 0 ? Number(status.custom_currency_exchange_rate) : 1;
+    return { unit: 'CUSTOM', symbol: status?.custom_currency_symbol || '¤', factor: customRate / perUnit, perUnit, estimated: false };
+  }
+  return { unit: 'USD', symbol: '$', factor: 1 / perUnit, perUnit, estimated: status === undefined };
+}
+
+function amount(quota, display) {
+  if (!Number.isFinite(quota)) return null;
+  return Math.round(quota * display.factor * 10000) / 10000;
+}
+
+export class BalanceService {
+  constructor({ capture, connection, apiKey, logger }) {
+    this.capture = capture ?? (() => { const conn = connection(); return { connection: conn, requireApiKey: () => apiKey(conn) }; });
+    this.logger = logger;
+    this.state = { status: 'idle' };
+    this.statusDoc = undefined;
+    this.statusAt = 0;
+    this.backoffUntil = 0;
+    this.inflight = undefined;
+  }
+
+  async serverStatus(root, headers) {
+    if (this.statusDoc && this.statusRoot === root && Date.now() - this.statusAt < 30 * 60 * 1000) return this.statusDoc;
+    if (this.statusRoot !== root) this.statusDoc = undefined;
+    try {
+      // Same gateway, same extra headers as every other request (header-gated proxies).
+      const doc = await fetchJson(`${root}/api/status`, { headers });
+      this.statusDoc = doc?.data ?? doc;
+      this.statusRoot = root;
+      this.statusAt = Date.now();
+    } catch (error) {
+      this.logger?.warn?.(`newapi-provider: /api/status unavailable: ${error.message}`);
+    }
+    return this.statusDoc;
+  }
+
+  /** Refresh unless rate-limited; concurrent callers share one request. */
+  refresh({ force = false } = {}) {
+    if (!force && Date.now() < this.backoffUntil) return Promise.resolve(this.state);
+    this.inflight ??= this.load().finally(() => { this.inflight = undefined; });
+    return this.inflight;
+  }
+
+  async load() {
+    let apiKey;
+    let root;
+    let headers;
+    try {
+      const bound = this.capture();
+      root = gatewayRoot(bound.connection.baseURL);
+      headers = bound.connection.headers;
+      apiKey = await bound.requireApiKey();
+    } catch (error) {
+      this.state = { status: 'error', code: 'MISSING_CREDENTIAL', message: error.message, at: Date.now() };
+      return this.state;
+    }
+    try {
+      const status = await this.serverStatus(root, headers);
+      const display = displayOf(status);
+      const usage = await fetchJson(`${root}/api/usage/token/`, { apiKey, headers });
+      const d = usage?.data ?? usage;
+      if (usage?.code === false || !d || typeof d !== 'object') throw new GatewayError(usage?.message || 'unexpected /api/usage/token response', 'BAD_RESPONSE');
+      const unlimited = d.unlimited_quota === true;
+      const token = {
+        name: d.name ?? null,
+        unlimited,
+        used: amount(d.total_used, display),
+        granted: unlimited ? null : amount(d.total_granted, display),
+        remaining: unlimited ? null : amount(d.total_available, display),
+        expiresAt: d.expires_at > 0 ? d.expires_at * (d.expires_at < 1e12 ? 1000 : 1) : null,
+        modelLimits: d.model_limits_enabled ? Object.keys(d.model_limits ?? {}) : null,
+      };
+      const user = d.user_quota && typeof d.user_quota === 'object'
+        ? { remaining: amount(d.user_quota.total_available, display), used: amount(d.user_quota.total_used, display) }
+        : null;
+      this.state = {
+        status: 'ok',
+        at: Date.now(),
+        currency: { unit: display.unit, symbol: display.symbol, estimated: display.estimated },
+        token,
+        user,
+        userQuotaHint: user ? null : 'enable-allow-user-quota-query',
+        serverVersion: status?.version ?? null,
+        systemName: status?.system_name ?? null,
+      };
+      this.backoffUntil = 0;
+    } catch (error) {
+      if (error.code === 'RATE_LIMIT') this.backoffUntil = Date.now() + (error.retryAfterMs ?? 60_000);
+      this.state = {
+        ...(this.state.status === 'ok' ? this.state : {}),
+        status: this.state.status === 'ok' ? 'stale' : 'error',
+        code: error.code ?? 'ERROR',
+        message: error.message,
+        errorAt: Date.now(),
+      };
+    }
+    return this.state;
+  }
+}

package/lib/catalog.js

@@ -0,0 +1,207 @@
+/**
+ * Gateway model catalog.
+ *
+ * Sources, lowest to highest precedence:
+ *   1. GET /v1/models           — ids and supported_endpoint_types
+ *   2. GET /api/pricing         — vendor, quota type, ratios, per-call price
+ *   3. models.dev               — context window, output cap, modalities, reasoning
+ *   4. user overrides (config)  — anything the user pins
+ *
+ * Every entry carries a `kind` (chat / image / video / audio / embedding /
+ * other) so chat models go to the picker and media models go to the tools.
+ */
+import { fetchJson, gatewayRoot } from './util.js';
+
+export const DEFAULT_CONTEXT_WINDOW = 128_000;
+export const DEFAULT_MAX_TOKENS = 32_768;
+const CATALOG_TTL_MS = 10 * 60 * 1000;
+
+/** Name rules used only when models.dev has no output-modality data. */
+const KIND_PATTERNS = [
+  ['video', /(^|[-_/])(sora|veo|kling|vidu|hailuo|seedance|wan\d|wanx|cogvideo|happyhorse|video|t2v|i2v|runway|luma|pika)/i],
+  ['image', /(^|[-_/])(gpt-image|dall-e|imagen|flux|midjourney|mj[-_]|seedream|cogview|stable-diffusion|sdxl|sd3|recraft|ideogram|image)/i],
+  ['audio', /(^|[-_/])(tts|whisper|speech|audio|suno|voice)/i],
+  ['embedding', /(embed|embedding|rerank|bge-|text-embedding)/i],
+];
+
+export function classify(id, dev) {
+  const out = dev?.outputModalities ?? [];
+  if (out.includes('video')) return 'video';
+  if (out.includes('image') && !out.includes('text')) return 'image';
+  if (out.includes('audio') && !out.includes('text')) return 'audio';
+  for (const [kind, re] of KIND_PATTERNS) if (re.test(id)) return kind;
+  if (out.includes('text') || out.length === 0) return 'chat';
+  return 'other';
+}
+
+/** One-hop wire identity. Empty legacy/config values retain the local id. */
+export function upstreamModelOf(entry) {
+  return typeof entry?.upstreamModel === 'string' && entry.upstreamModel.trim() ? entry.upstreamModel.trim() : entry.id;
+}
+
+function prettyName(id) {
+  return id;
+}
+
+export class Catalog {
+  constructor({ modelsDev, logger }) {
+    this.modelsDev = modelsDev;
+    this.logger = logger;
+    this.cache = new Map();
+    this.epoch = 0;
+  }
+
+  invalidate() {
+    this.epoch++;
+    this.cache.clear();
+  }
+
+  /**
+   * Fetch the raw gateway lists. /v1/models is required; /api/pricing is
+   * optional because some deployments hide the pricing page.
+   */
+  async fetchGateway(conn, apiKey, signal) {
+    const root = gatewayRoot(conn.baseURL);
+    const models = await fetchJson(`${root}/v1/models`, { apiKey, signal, headers: conn.headers });
+    let pricing;
+    let pricingError;
+    try {
+      pricing = await fetchJson(`${root}/api/pricing`, { apiKey, signal, headers: conn.headers });
+    } catch (error) {
+      pricingError = String(error?.message ?? error);
+    }
+    return { models, pricing, pricingError };
+  }
+
+  /** Full catalog for one connection, cached per base URL + key fingerprint. */
+  async get(conn, apiKey, { signal, force = false } = {}) {
+    const key = this.key(conn);
+    const epoch = this.epoch;
+    const hit = this.cache.get(key);
+    if (!force && hit && Date.now() - hit.at < CATALOG_TTL_MS && hit.overridesRev === conn.overridesRev) return hit.value;
+    void this.modelsDev.refresh();
+    const raw = await this.fetchGateway(conn, apiKey, signal);
+    const value = this.build(conn, raw);
+    if (epoch === this.epoch) this.cache.set(key, { at: Date.now(), value, overridesRev: conn.overridesRev });
+    return value;
+  }
+
+  /** Last good catalog for a connection without network, if any. */
+  key(conn) {
+    return JSON.stringify([conn.channelId, gatewayRoot(conn.baseURL), conn.keyFingerprint, conn.overridesRev, conn.headers, conn.enabledModels ?? null]);
+  }
+
+  peek(conn) {
+    return this.cache.get(this.key(conn))?.value;
+  }
+
+  build(conn, { models, pricing, pricingError }) {
+    const priced = new Map();
+    for (const p of pricing?.data ?? []) priced.set(p.model_name, p);
+    const vendors = new Map((pricing?.vendors ?? []).map((v) => [v.id, v.name]));
+    const overrides = conn.overrides;
+    const entries = [];
+    const seen = new Set();
+
+    const gateway = new Map();
+    for (const m of models?.data ?? []) if (m?.id && !gateway.has(m.id)) gateway.set(m.id, m);
+    const make = (id, localGatewayEntry) => {
+      // Own-property read: ids like `toString` or `constructor` are legal model names.
+      const ov = (Object.hasOwn(overrides ?? {}, id) ? overrides[id] : undefined) ?? {};
+      const upstreamModel = upstreamModelOf({ id, upstreamModel: ov.upstreamModel });
+      const targetGatewayEntry = gateway.get(upstreamModel);
+      const targetPrice = priced.get(upstreamModel);
+      const price = targetPrice ?? priced.get(id);
+      const targetDev = this.modelsDev.match(upstreamModel);
+      const dev = targetDev ?? (upstreamModel !== id ? this.modelsDev.match(id) : undefined);
+      const kind = ov.kind ?? classify(upstreamModel, dev);
+      const endpointTypes = ov.protocol
+        ? [ov.protocol]
+        : (targetGatewayEntry?.supported_endpoint_types ?? targetPrice?.supported_endpoint_types ?? localGatewayEntry?.supported_endpoint_types ?? price?.supported_endpoint_types ?? []);
+      const devInput = (dev?.input ?? []).filter((m) => typeof m === 'string');
+      const input = ov.input ?? (devInput.length ? devInput : ['text']);
+      return {
+        id,
+        upstreamModel,
+        availability: gateway.has(upstreamModel) ? 'listed' : ov.custom === true ? 'custom' : 'missing',
+        automaticContextWindow: dev?.context > 0 ? dev.context : conn.defaultContextWindow ?? DEFAULT_CONTEXT_WINDOW,
+        automaticMaxTokens: dev?.output > 0 ? dev.output : conn.defaultMaxTokens ?? DEFAULT_MAX_TOKENS,
+        name: ov.name ?? prettyName(id),
+        kind,
+        hidden: ov.hidden === true,
+        endpointTypes,
+        vendor: price ? (vendors.get(price.vendor_id) ?? null) : null,
+        pricing: price ? {
+          quotaType: price.quota_type === 1 ? 'per-call' : 'per-token',
+          modelRatio: price.model_ratio,
+          completionRatio: price.completion_ratio,
+          modelPrice: price.model_price,
+          cacheRatio: price.create_cache_ratio,
+          groups: price.enable_groups ?? [],
+        } : null,
+        contextWindow: ov.contextWindow ?? (dev?.context > 0 ? dev.context : undefined),
+        maxTokens: ov.maxTokens ?? (dev?.output > 0 ? dev.output : undefined),
+        input,
+        automaticInput: devInput.length ? devInput : ['text'],
+        automaticReasoning: dev?.reasoning ?? false,
+        outputModalities: dev?.outputModalities ?? [],
+        reasoning: ov.reasoning ?? dev?.reasoning ?? false,
+        reasoningLevels: ov.reasoningLevels,
+        source: {
+          gateway: Boolean(localGatewayEntry),
+          upstreamGateway: gateway.has(upstreamModel),
+          metadataModel: targetDev ? upstreamModel : id,
+          pricingModel: price ? (priced.has(upstreamModel) ? upstreamModel : id) : null,
+          modelsDev: dev ? { provider: dev.provider, match: dev.match } : null,
+          overridden: Object.keys(ov).filter((k) => ov[k] !== undefined),
+        },
+      };
+    };
+
+    const enabled = Array.isArray(conn.enabledModels) ? conn.enabledModels : undefined;
+
+    if (enabled) {
+      // List mode: exactly the saved list, in saved order. Ids the gateway no
+      // longer returns stay visible and marked, so the user decides.
+      for (const id of enabled) {
+        if (seen.has(id)) continue;
+        seen.add(id);
+        const g = gateway.get(id);
+        const entry = make(id, g);
+        entries.push(entry);
+      }
+    } else {
+      // Automatic mode (configs from before the list existed): every gateway model.
+      for (const [id, g] of gateway) {
+        seen.add(id);
+        const entry = make(id, g);
+        entries.push(entry);
+      }
+      for (const id of Object.keys(overrides)) {
+        if (seen.has(id) || !Object.hasOwn(overrides, id) || overrides[id]?.custom !== true) continue;
+        seen.add(id);
+        const entry = make(id, undefined);
+        entries.push(entry);
+      }
+    }
+    return {
+      fetchedAt: Date.now(),
+      listMode: enabled ? 'list' : 'auto',
+      gatewayIds: [...gateway.keys()],
+      entries,
+      pricingAvailable: Boolean(pricing),
+      pricingError: pricingError ?? null,
+      supportedEndpoints: pricing?.supported_endpoint ?? null,
+      groupRatio: pricing?.group_ratio ?? null,
+    };
+  }
+}
+
+/** Chat models visible in the picker, in gateway order. */
+export function chatModels(catalog) {
+  return (catalog?.entries ?? []).filter((e) => e.kind === 'chat' && !e.hidden);
+}
+
+export function mediaModels(catalog, kind) {
+  return (catalog?.entries ?? []).filter((e) => e.kind === kind && !e.hidden);
+}