@fonlan/dsh-model-parameters 0.1.0

package/src/client/settings-section.tsx

@@ -0,0 +1,310 @@
+/**
+ * The Model Parameters settings page: master + per-field toggles, catalog TTL,
+ * provider→models.dev mapping overrides, a manual refresh/fill action, the
+ * catalog freshness card, and the last fill report (filled / touched /
+ * unmatched). All reads/mutations go through the plugin's fenced API; config
+ * persists into the `model-parameters` settings namespace (settings.yaml).
+ */
+import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from 'react'
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client'
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots'
+import { LOCALE_NS } from './locales'
+import { api, type PluginState } from './api'
+import type { ModelParametersConfig } from '../shared/config.js'
+import './settings-section.css'
+
+function useLocaleRevision(ctx: ClientContext): number {
+  const subscribe = useCallback(
+    (onChange: () => void) => {
+      try {
+        return ctx.locale.subscribe(onChange)
+      } catch {
+        return () => {}
+      }
+    },
+    [ctx],
+  )
+  const getSnapshot = useCallback(() => {
+    try {
+      return ctx.locale.getLocale().revision
+    } catch {
+      return 0
+    }
+  }, [ctx])
+  return useSyncExternalStore(subscribe, getSnapshot)
+}
+
+function formatTime(epochMs: number): string {
+  try {
+    return new Date(epochMs).toLocaleString()
+  } catch {
+    return String(epochMs)
+  }
+}
+
+export function makeSettingsSection(ctx: ClientContext): () => JSX.Element {
+  const t: Translate = (() => {
+    try {
+      return ctx.locale.bind(LOCALE_NS) as unknown as Translate
+    } catch {
+      return (key: string) => key
+    }
+  })()
+
+  return function ModelParametersSettingsSection(): JSX.Element {
+    useLocaleRevision(ctx)
+    const [state, setState] = useState<PluginState | null>(null)
+    const [error, setError] = useState<string | null>(null)
+    const [loading, setLoading] = useState(true)
+    const [busy, setBusy] = useState(false)
+    const [saving, setSaving] = useState(false)
+    const [mappingRows, setMappingRows] = useState<Array<{ from: string; to: string }>>([])
+    const [newFrom, setNewFrom] = useState('')
+    const [newTo, setNewTo] = useState('')
+
+    const load = useCallback(async () => {
+      setLoading(true)
+      try {
+        const next = await api.state()
+        setState(next)
+        setMappingRows(Object.entries(next.config.providerMap).map(([from, to]) => ({ from, to })))
+        setError(null)
+      } catch (cause) {
+        setError(cause instanceof Error ? cause.message : String(cause))
+      } finally {
+        setLoading(false)
+      }
+    }, [])
+
+    useEffect(() => {
+      void load()
+    }, [load])
+
+    const patchConfig = useCallback(async (patch: Partial<ModelParametersConfig>) => {
+      setSaving(true)
+      try {
+        const next = await api.setConfig(patch)
+        setState(next)
+        setMappingRows(Object.entries(next.config.providerMap).map(([from, to]) => ({ from, to })))
+        setError(null)
+      } catch (cause) {
+        setError(cause instanceof Error ? cause.message : String(cause))
+      } finally {
+        setSaving(false)
+      }
+    }, [])
+
+    const refresh = useCallback(async () => {
+      setBusy(true)
+      try {
+        setState(await api.refresh())
+        setError(null)
+      } catch (cause) {
+        setError(cause instanceof Error ? cause.message : String(cause))
+      } finally {
+        setBusy(false)
+      }
+    }, [])
+
+    const reconcileNow = useCallback(async () => {
+      setBusy(true)
+      try {
+        setState(await api.reconcile())
+        setError(null)
+      } catch (cause) {
+        setError(cause instanceof Error ? cause.message : String(cause))
+      } finally {
+        setBusy(false)
+      }
+    }, [])
+
+    const applyMappings = useCallback(async () => {
+      const providerMap: Record<string, string> = {}
+      for (const row of mappingRows) {
+        const from = row.from.trim()
+        const to = row.to.trim()
+        if (from.length > 0 && to.length > 0) providerMap[from] = to
+      }
+      await patchConfig({ providerMap })
+    }, [mappingRows, patchConfig])
+
+    if (error !== null && state === null) {
+      return (
+        <p className="mp-error">{t('error')}: {error}</p>
+      )
+    }
+    if (loading || state === null) {
+      return <p className="mp-muted">{t('saving')}</p>
+    }
+
+    const config = state.config
+    const catalog = state.catalog
+    const report = state.report
+
+    return (
+      <div className="mp-root">
+        <p className="mp-desc">{t('description')}</p>
+
+        <section className="mp-card">
+          <h4 className="mp-card-title">{t('fields')}</h4>
+          <label className="mp-toggle">
+            <input
+              type="checkbox"
+              checked={config.enabled}
+              disabled={saving}
+              onChange={(event) => void patchConfig({ enabled: event.target.checked })}
+            />
+            <span className="mp-toggle-body">
+              <span className="mp-toggle-label">{t('master')}</span>
+              <span className="mp-toggle-desc">{t('masterDesc')}</span>
+            </span>
+          </label>
+          {([
+            ['fillName', t('fillName'), t('fillNameDesc')],
+            ['fillContext', t('fillContext'), t('fillContextDesc')],
+            ['fillMaxTokens', t('fillMaxTokens'), t('fillMaxTokensDesc')],
+            ['fillReasoning', t('fillReasoning'), t('fillReasoningDesc')],
+            ['fillInput', t('fillInput'), t('fillInputDesc')],
+          ] as const).map(([key, label, desc]) => (
+            <label className="mp-toggle mp-toggle-sub" key={key}>
+              <input
+                type="checkbox"
+                checked={config[key]}
+                disabled={saving || !config.enabled}
+                onChange={(event) => void patchConfig({ [key]: event.target.checked })}
+              />
+              <span className="mp-toggle-body">
+                <span className="mp-toggle-label">{label}</span>
+                <span className="mp-toggle-desc">{desc}</span>
+              </span>
+            </label>
+          ))}
+        </section>
+
+        <section className="mp-card">
+          <h4 className="mp-card-title">{t('catalog')}</h4>
+          <div className="mp-meta">
+            <span>{t('catalogEntries')}: <strong>{catalog.entries.toLocaleString()}</strong></span>
+            <span>{t('catalogProviders')}: <strong>{catalog.providers.toLocaleString()}</strong></span>
+            <span>
+              {t('catalogFetched')}:{' '}
+              <strong>{catalog.fetchedAt > 0 ? formatTime(catalog.fetchedAt) : t('catalogNever')}</strong>{' '}
+              {catalog.fetchedAt > 0 && (
+                <span className={catalog.fresh ? 'mp-badge mp-badge-ok' : 'mp-badge mp-badge-warn'}>
+                  {catalog.fresh ? t('catalogFresh') : t('catalogStale')}
+                </span>
+              )}
+            </span>
+            <label className="mp-ttl">
+              {t('ttl')}
+              <input
+                type="number"
+                min={1}
+                max={90}
+                value={config.ttlDays}
+                disabled={saving}
+                onChange={(event) => {
+                  const days = Number(event.target.value)
+                  if (Number.isFinite(days) && days >= 1 && days <= 90) void patchConfig({ ttlDays: Math.round(days) })
+                }}
+              />
+            </label>
+          </div>
+          <div className="mp-actions">
+            <button className="mp-button" disabled={busy} onClick={() => void refresh()}>
+              {busy ? t('refreshBusy') : t('refresh')}
+            </button>
+            <button className="mp-button mp-button-ghost" disabled={busy} onClick={() => void reconcileNow()}>
+              {t('reconcileNow')}
+            </button>
+          </div>
+        </section>
+
+        <section className="mp-card">
+          <h4 className="mp-card-title">{t('providerMap')}</h4>
+          <p className="mp-toggle-desc">{t('providerMapDesc')}</p>
+          {mappingRows.map((row, index) => (
+            <div className="mp-map-row" key={index}>
+              <input
+                value={row.from}
+                disabled={saving}
+                onChange={(event) => {
+                  const next = [...mappingRows]
+                  next[index] = { ...row, from: event.target.value }
+                  setMappingRows(next)
+                }}
+              />
+              <span className="mp-map-arrow">→</span>
+              <input
+                value={row.to}
+                disabled={saving}
+                onChange={(event) => {
+                  const next = [...mappingRows]
+                  next[index] = { ...row, to: event.target.value }
+                  setMappingRows(next)
+                }}
+              />
+              <button
+                className="mp-button mp-button-ghost"
+                disabled={saving}
+                onClick={() => setMappingRows(mappingRows.filter((_, i) => i !== index))}
+              >
+                {t('removeMapping')}
+              </button>
+            </div>
+          ))}
+          <div className="mp-map-row">
+            <input
+              placeholder="dsh provider"
+              value={newFrom}
+              onChange={(event) => setNewFrom(event.target.value)}
+            />
+            <span className="mp-map-arrow">→</span>
+            <input
+              placeholder="models.dev provider"
+              value={newTo}
+              onChange={(event) => setNewTo(event.target.value)}
+            />
+            <button
+              className="mp-button"
+              disabled={newFrom.trim().length === 0 || newTo.trim().length === 0}
+              onClick={() => {
+                setMappingRows([...mappingRows, { from: newFrom.trim(), to: newTo.trim() }])
+                setNewFrom('')
+                setNewTo('')
+              }}
+            >
+              {t('addMapping')}
+            </button>
+          </div>
+          <div className="mp-actions">
+            <button className="mp-button mp-button-ghost" disabled={saving} onClick={() => void applyMappings()}>
+              {saving ? t('saving') : '✓ ' + t('providerMap')}
+            </button>
+          </div>
+        </section>
+
+        <section className="mp-card">
+          <h4 className="mp-card-title">{t('report')}</h4>
+          {report === null ? (
+            <p className="mp-muted">{t('reportNever')}</p>
+          ) : (
+            <ul className="mp-report">
+              <li>{t('reportAt')}: {formatTime(report.at)}</li>
+              <li>{t('reportFilled')}: <strong>{report.filled}</strong></li>
+              <li>{t('reportTouched')}: <strong>{report.touched}</strong></li>
+              <li>
+                {t('reportUnmatched')}:{' '}
+                {report.unmatched.length === 0
+                  ? t('reportEmpty')
+                  : <code className="mp-code">{report.unmatched.join(', ')}</code>}
+              </li>
+            </ul>
+          )}
+        </section>
+
+        {error !== null && <p className="mp-error">{error}</p>}
+      </div>
+    )
+  }
+}

package/src/client/slot-augment.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Declare this plugin's locale namespace so slot registrations can type-check
+ * the `locale` seat. zh is the key source of truth; en must carry the exact
+ * same key set (checked at runtime by the locale registry).
+ */
+import type { zh } from './locales'
+
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+  interface LocaleNamespaceMap {
+    'model-parameters': keyof typeof zh
+  }
+}
+
+export {}

package/src/index.ts

@@ -0,0 +1,47 @@
+/**
+ * @fonlan/dsh-model-parameters host half.
+ *
+ * Watches the `llm-pi-ai` settings namespace: whenever provider models are
+ * written there with missing display name / context window / max output
+ * tokens / reasoning efforts / input modalities (the norm for a freshly
+ * synced gateway), it fills the missing fields from a cached models.dev
+ * catalog (TTL-refreshed), and serves the fenced JSON API the web settings
+ * page calls. The plugin's own toggles live in the `model-parameters`
+ * settings namespace (settings.yaml).
+ */
+import type { Context } from '@deepseek-ai/cordis'
+import { Config } from './shared/config.js'
+import { ModelParametersService } from './server/service.js'
+import { registerApiRoutes } from './server/rpc.js'
+import {
+  CatalogManager,
+  acceptedInputModalities,
+  identityReasoningEfforts,
+  type CatalogEntry,
+  type CatalogSnapshot,
+} from './server/catalog.js'
+
+export const name = '@fonlan/dsh-model-parameters'
+
+// Nothing is hard-required at apply time: the settings service is attached
+// opportunistically (web, CLI, headless all work — headless profiles just
+// expose no settings page), and the web server only exists in web profiles.
+export const inject: string[] = []
+
+export { Config }
+export { CatalogManager, acceptedInputModalities, identityReasoningEfforts }
+export type { CatalogEntry, CatalogSnapshot }
+
+export function apply(ctx: Context): void {
+  const service = new ModelParametersService(ctx)
+
+  ctx.effect(() => {
+    service.start()
+    return () => service.stop()
+  }, 'model-parameters: service')
+
+  // The settings-page API only exists where a web server does.
+  ctx.inject(['webServer'], (sctx) => {
+    sctx.effect(() => registerApiRoutes(sctx, service), 'model-parameters: api routes')
+  })
+}

package/src/server/catalog.ts

@@ -0,0 +1,300 @@
+/**
+ * models.dev catalog: fetch, disk cache, lazy TTL refresh, and id matching.
+ *
+ * The catalog is flattened into a list of entries keyed by provider, then
+ * indexed by the last path segment of the model id (case-insensitive) so a
+ * synced bare id like `qwen3.7-max` can resolve `Qwen/Qwen3.7-Max` wherever
+ * models.dev carries it.
+ *
+ * Collisions are real: the same bare id appears under dozens of providers with
+ * different limits. Resolution is deterministic and provider-aware:
+ *   1. the models.dev provider mapped for the dsh provider (providerMap
+ *      override, then same provider id);
+ *   2. an exact full-id match (the dsh model id already carries a vendor/);
+ *   3. first-party vendor list position (officialProviders);
+ *   4. entry completeness (both context and output limits known);
+ *   5. alphabetical provider id (stable last resort).
+ */
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import {
+  ACCEPTED_INPUT_MODALITIES,
+  CATALOG_URL,
+  REASONING_LEVELS,
+  type ModelParametersConfig,
+} from '../shared/config.js'
+
+/** Structural logger subset satisfied by cordis' LoggerService. */
+export interface CatalogLogger {
+  info(format: any, ...param: any[]): void
+  warn(format: any, ...param: any[]): void
+}
+
+/** One flattened models.dev entry. */
+export interface CatalogEntry {
+  /** models.dev provider id that carries this model. */
+  provider: string
+  /** Full model id as models.dev keys it (may carry a vendor/ prefix). */
+  id: string
+  /** Display name. */
+  name?: string
+  /** Context window in tokens, when known. */
+  context?: number
+  /** Output limit in tokens, when known. */
+  output?: number
+  /** Whether the model reasons at all, when stated. */
+  reasoning?: boolean
+  /** Offered reasoning effort levels (e.g. ["low","high","max"]). */
+  effortValues?: string[]
+  /** Accepted request modalities, raw from models.dev (may include pdf/audio/video). */
+  input?: string[]
+}
+
+export interface CatalogSnapshot {
+  /** Flattened entries in stable provider order. */
+  entries: CatalogEntry[]
+  /** Number of models.dev providers covered. */
+  providers: number
+  /** Epoch ms the cache was last fetched (0 = never fetched). */
+  fetchedAt: number
+}
+
+const DAY_MS = 24 * 60 * 60 * 1000
+const FETCH_TIMEOUT_MS = 20_000
+
+function strippedId(id: string): string {
+  const last = id.split('/').pop() ?? id
+  return last.toLowerCase()
+}
+
+function isOfficial(provider: string, official: readonly string[]): number {
+  const index = official.indexOf(provider)
+  return index === -1 ? official.length : index
+}
+
+function completeness(entry: CatalogEntry): number {
+  return entry.context !== undefined && entry.output !== undefined ? 0 : 1
+}
+
+/** The cached raw document on disk: the api.json body plus fetch metadata. */
+interface CacheDocument {
+  fetchedAt: number
+  body: Record<string, unknown>
+}
+
+export class CatalogManager {
+  private snapshot: CatalogSnapshot = { entries: [], providers: 0, fetchedAt: 0 }
+  private loaded = false
+  private inflight: Promise<void> | null = null
+  private readonly dir: string
+  private readonly cachePath: string
+
+  constructor(
+    private readonly logger: CatalogLogger,
+    dataDir?: string,
+  ) {
+    this.dir = dataDir ?? join(homedir(), '.dsh', 'model-parameters')
+    this.cachePath = join(this.dir, 'catalog.json')
+  }
+
+  /** The current snapshot (empty until the first load/fetch completes). */
+  snapshotOf(): CatalogSnapshot {
+    return this.snapshot
+  }
+
+  /**
+   * Load the disk cache once, then fetch when stale (or `force`). A failed
+   * fetch keeps the last good cache; with no cache at all the snapshot stays
+   * empty and the caller simply fills nothing. Concurrent callers share one
+   * in-flight refresh.
+   * @returns true when the snapshot may have changed.
+   */
+  async ensureFresh(config: Pick<ModelParametersConfig, 'ttlDays'>, force = false): Promise<boolean> {
+    if (!this.loaded) {
+      await this.loadCache()
+      this.loaded = true
+    }
+    const stale = Date.now() - this.snapshot.fetchedAt >= config.ttlDays * DAY_MS
+    if (!force && !stale) return false
+    if (this.inflight !== null) {
+      await this.inflight
+      return true
+    }
+    this.inflight = this.fetchAndPersist()
+      .catch((error) => {
+        this.logger.warn(
+          `model-parameters: catalog fetch failed (${error instanceof Error ? error.message : String(error)}); using cached copy`,
+        )
+      })
+      .finally(() => {
+        this.inflight = null
+      })
+    await this.inflight
+    return true
+  }
+
+  /** Force a fetch now; never throws (falls back to cache or keeps empty). */
+  async refresh(ttlDays: number): Promise<boolean> {
+    return this.ensureFresh({ ttlDays }, true)
+  }
+
+  /**
+   * Resolve one dsh model id to the best catalog entry for its provider.
+   * @param modelId - the model id stored in the dsh provider profile.
+   * @param dshProvider - the dsh provider route id.
+   * @param config - plugin config (providerMap + officialProviders).
+   */
+  resolve(modelId: string, dshProvider: string, config: Pick<ModelParametersConfig, 'providerMap' | 'officialProviders'>): CatalogEntry | undefined {
+    const mapped = config.providerMap[dshProvider]
+    const candidates = this.candidatesFor(modelId)
+    if (candidates.length === 0) return undefined
+    const official = config.officialProviders
+
+    const score = (entry: CatalogEntry): number[] => {
+      const providerMatch = entry.provider === mapped || entry.provider === dshProvider ? 0 : 1
+      const exact = modelId.includes('/') && strippedId(entry.id) === modelId.toLowerCase() ? 0 : 1
+      return [providerMatch, exact, isOfficial(entry.provider, official), completeness(entry)]
+    }
+
+    // Stable total order: score tuple, then provider id, then full id.
+    candidates.sort((a, b) => {
+      const sa = score(a)
+      const sb = score(b)
+      for (let i = 0; i < sa.length; i++) {
+        if (sa[i] !== sb[i]) return sa[i] - sb[i]
+      }
+      if (a.provider !== b.provider) return a.provider < b.provider ? -1 : 1
+      return a.id < b.id ? -1 : 1
+    })
+    return candidates[0]
+  }
+
+  /**
+   * All entries whose stripped id matches, plus any whose full id matches
+   * exactly (a dsh model id may already carry a vendor/ prefix that models.dev
+   * keys verbatim).
+   */
+  private candidatesFor(modelId: string): CatalogEntry[] {
+    const stripped = strippedId(modelId)
+    const out: CatalogEntry[] = []
+    for (const entry of this.snapshot.entries) {
+      if (strippedId(entry.id) === stripped) out.push(entry)
+      else if (modelId.includes('/') && entry.id.toLowerCase() === modelId.toLowerCase()) out.push(entry)
+    }
+    return out
+  }
+
+  // ── disk / wire ────────────────────────────────────────────────────────────
+
+  private async loadCache(): Promise<void> {
+    try {
+      const raw = await readFile(this.cachePath, 'utf8')
+      const doc = JSON.parse(raw) as CacheDocument
+      if (typeof doc.fetchedAt !== 'number' || typeof doc.body !== 'object' || doc.body === null) {
+        this.logger.warn('model-parameters: catalog cache is malformed; ignoring')
+        return
+      }
+      this.snapshot = this.buildSnapshot(doc.body, doc.fetchedAt)
+      this.logger.info(
+        `model-parameters: loaded ${this.snapshot.entries.length} catalog entries from cache (fetched ${new Date(doc.fetchedAt).toISOString()})`,
+      )
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code
+      if (code !== 'ENOENT') {
+        this.logger.warn(`model-parameters: catalog cache read failed: ${error instanceof Error ? error.message : String(error)}`)
+      }
+    }
+  }
+
+  private async fetchAndPersist(): Promise<void> {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS)
+    let response: Response
+    try {
+      response = await fetch(CATALOG_URL, { signal: controller.signal, headers: { accept: 'application/json' } })
+    } finally {
+      clearTimeout(timer)
+    }
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} ${response.statusText}`)
+    }
+    const body = (await response.json()) as Record<string, unknown>
+    const fetchedAt = Date.now()
+    this.snapshot = this.buildSnapshot(body, fetchedAt)
+    await mkdir(this.dir, { recursive: true })
+    const doc: CacheDocument = { fetchedAt, body }
+    await writeFile(this.cachePath, JSON.stringify(doc), 'utf8')
+    this.logger.info(
+      `model-parameters: catalog refreshed from models.dev (${this.snapshot.providers} providers, ${this.snapshot.entries.length} models)`,
+    )
+  }
+
+  private buildSnapshot(body: Record<string, unknown>, fetchedAt: number): CatalogSnapshot {
+    const entries: CatalogEntry[] = []
+    for (const [provider, raw] of Object.entries(body)) {
+      if (typeof raw !== 'object' || raw === null) continue
+      const providerDoc = raw as Record<string, unknown>
+      const models = providerDoc.models
+      if (typeof models !== 'object' || models === null) continue
+      for (const [id, rawModel] of Object.entries(models as Record<string, unknown>)) {
+        if (typeof rawModel !== 'object' || rawModel === null) continue
+        const model = rawModel as Record<string, unknown>
+        const limit = (typeof model.limit === 'object' && model.limit !== null ? model.limit : {}) as Record<string, unknown>
+        const entry: CatalogEntry = { provider, id }
+        if (typeof model.name === 'string' && model.name.length > 0) entry.name = model.name
+        if (typeof limit.context === 'number') entry.context = limit.context
+        if (typeof limit.output === 'number') entry.output = limit.output
+        if (typeof model.reasoning === 'boolean') entry.reasoning = model.reasoning
+        const effortValues: string[] = []
+        if (Array.isArray(model.reasoning_options)) {
+          for (const option of model.reasoning_options) {
+            if (typeof option === 'object' && option !== null && (option as Record<string, unknown>).type === 'effort') {
+              const values = (option as Record<string, unknown>).values
+              if (Array.isArray(values)) {
+                for (const value of values) {
+                  if (typeof value === 'string') effortValues.push(value)
+                }
+              }
+            }
+          }
+        }
+        if (effortValues.length > 0) entry.effortValues = effortValues
+        const modalities = (typeof model.modalities === 'object' && model.modalities !== null ? model.modalities : {}) as Record<string, unknown>
+        if (Array.isArray(modalities.input)) {
+          const input = modalities.input.filter((value): value is string => typeof value === 'string')
+          if (input.length > 0) entry.input = input
+        }
+        entries.push(entry)
+      }
+    }
+    return { entries, providers: Object.keys(body).length, fetchedAt }
+  }
+}
+
+/**
+ * Build the dsh `reasoningEfforts` identity dict from models.dev effort
+ * values, filtered to the levels dsh accepts. Returns undefined when nothing
+ * valid is offered (or the model does not state reasoning).
+ */
+export function identityReasoningEfforts(entry: CatalogEntry): Record<string, string> | undefined {
+  if (entry.reasoning === false) return undefined
+  if (entry.effortValues === undefined || entry.effortValues.length === 0) return undefined
+  const efforts: Record<string, string> = {}
+  for (const value of entry.effortValues) {
+    if (REASONING_LEVELS.includes(value)) efforts[value] = value
+  }
+  return Object.keys(efforts).length > 0 ? efforts : undefined
+}
+
+/**
+ * The dsh-writable input modality list for one entry: models.dev values
+ * intersected with what pi-ai accepts. Returns undefined when nothing is
+ * accepted (writing an empty list is semantically "keep defaults", so absent
+ * is the honest fill).
+ */
+export function acceptedInputModalities(entry: CatalogEntry): ('text' | 'image')[] | undefined {
+  if (entry.input === undefined || entry.input.length === 0) return undefined
+  const accepted = entry.input.filter((value): value is 'text' | 'image' => ACCEPTED_INPUT_MODALITIES.includes(value))
+  return accepted.length > 0 ? accepted : undefined
+}