dsh-model-capability-sync 0.0.0-stage → 0.1.0

package/src/client/apply.ts

@@ -0,0 +1,223 @@
+/**
+ * Browser half: one settings section plus the host RPC call it needs.
+ *
+ * The section is a `settings.section` slot of its own, so no shell edit is
+ * required. Configuration reads and writes go through the official settings
+ * remote (`remote.settings`), which is the same surface the shell's own Models
+ * page uses; the only custom channel is the catalog lookup, which must run
+ * host-side to avoid a cross-origin download.
+ * @module dsh-model-capability-sync/client
+ */
+import type { RpcEnvelope } from '../types.ts'
+import type { LiveResponse, PreviewRequest, PreviewResponse } from '../types.ts'
+import { SyncSection } from './SyncSection.tsx'
+import type { SettingsDescriptor, SettingsPathOp, SyncSectionInjected } from './SyncSection.tsx'
+import { en, zh } from './locale.ts'
+
+/** Copy namespace owned by this plugin. */
+const NS = 'settings.capability-sync'
+/** Own host RPC channel. */
+const CHANNEL = '/model-capability-sync'
+
+/** The slice of the browser context this plugin uses. */
+interface ClientContext {
+  effect(callback: () => (() => void) | void, label?: string): void
+  get(service: string): unknown
+  locale: {
+    register(ns: string, dictionaries: { zh: unknown; en: unknown }): () => void
+    bind(ns: string): (key: string, params?: Record<string, unknown>) => string
+  }
+  slots: {
+    inject(name: string, callback: () => () => void): void
+    register(options: Record<string, unknown>, component: unknown): () => void
+  }
+}
+
+/** The connection face carrying `rpc.call`. */
+interface ConnectionFace {
+  rpc: { call(channel: string, endpoint: string, payload: unknown): Promise<unknown> }
+}
+
+/** The remote face carrying the settings namespace. */
+interface RemoteFace {
+  settings: {
+    describe(): Promise<unknown>
+    mutate(ns: string, ops: SettingsPathOp[], expectedRevision?: number): Promise<unknown>
+  }
+}
+
+/** The document `settings.describe` answers with, once its envelope is opened. */
+interface SettingsDocument {
+  writable?: boolean
+  namespaces?: SettingsDescriptor[]
+}
+
+/** A refusal as the Remote namespace states it. */
+interface Refusal {
+  /** Machine-readable reason; `settings/conflict` is the one callers act on. */
+  code?: string
+  /** Human message for the page. */
+  message: string
+}
+
+/**
+ * Read the refusal out of a Remote answer envelope.
+ * @param answer - whatever the Remote namespace resolved with.
+ * @returns the refusal when the answer carries one, otherwise undefined.
+ */
+function refusalOf(answer: unknown): Refusal | undefined {
+  if (typeof answer !== 'object' || answer === null) return undefined
+  const envelope = answer as { ok?: unknown; error?: { code?: unknown; message?: unknown } }
+  if (envelope.ok !== false) return undefined
+  return {
+    ...typeof envelope.error?.code === 'string' ? { code: envelope.error.code } : {},
+    message: typeof envelope.error?.message === 'string' ? envelope.error.message : 'settings request refused',
+  }
+}
+
+/**
+ * Open a Remote answer envelope.
+ *
+ * Every `remote.settings` method answers `{ok: true, value}` or
+ * `{ok: false, error}`; a few surfaces hand back the bare value instead, so
+ * both shapes are accepted rather than guessed at one. A refusal keeps its
+ * `code`, so the section can tell a stale revision apart from a real failure.
+ * @param answer - whatever the Remote namespace resolved with.
+ * @returns the value the answer carries.
+ * @throws the refusal, carrying `code` when the answer had one.
+ */
+function unwrap(answer: unknown): unknown {
+  const refusal = refusalOf(answer)
+  if (refusal !== undefined) {
+    throw Object.assign(new Error(refusal.message), refusal.code === undefined ? {} : { code: refusal.code })
+  }
+  if (typeof answer === 'object' && answer !== null && 'ok' in answer && 'value' in answer) {
+    return (answer as { value: unknown }).value
+  }
+  return answer
+}
+
+/**
+ * The namespace views a describe answer carries.
+ * @param answer - the `settings.describe` answer, enveloped or bare.
+ * @returns every served namespace view.
+ * @throws when the answer holds no namespace list.
+ */
+function namespacesOf(answer: unknown): SettingsDescriptor[] {
+  const document = unwrap(answer) as SettingsDocument | SettingsDescriptor[] | undefined
+  if (Array.isArray(document)) return document
+  const namespaces = document?.namespaces
+  if (!Array.isArray(namespaces)) throw new Error('settings.describe returned no namespace list')
+  return namespaces
+}
+
+/** Required services (cordis fiber inject). */
+export const inject = ['slots', 'locale', 'connection', 'remote', 'remote.settings']
+
+/** Section styles, riding the shell's `--dsw-alias-*` tokens for both themes. */
+const SECTION_CSS = `
+.cs-field { display: flex; flex-direction: column; gap: 4px; margin-bottom: 12px; }
+.cs-row { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin-bottom: 12px; }
+.cs-select {
+  box-sizing: border-box; padding: 6px 10px; border-radius: 8px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  background: var(--dsw-alias-bg-layer-1);
+  color: var(--dsw-alias-label-primary);
+  font: inherit; font-size: 13px;
+}
+.cs-button {
+  padding: 6px 12px; border-radius: 6px; font: inherit; font-size: 13px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  background: transparent; color: var(--dsw-alias-label-primary);
+  cursor: pointer;
+}
+.cs-button:hover:not(:disabled) { background: var(--dsw-alias-interactive-bg-hover); }
+.cs-button:disabled { opacity: 0.4; cursor: default; }
+.cs-button--primary {
+  border-color: transparent;
+  background: var(--dsw-alias-button-primary-fill);
+  color: var(--dsw-alias-label-primary-foreground);
+}
+.cs-button--primary:hover:not(:disabled) { background: var(--dsw-alias-button-primary-hover); }
+.cs-hint { font-size: 12px; color: var(--dsw-alias-label-tertiary); line-height: 18px; }
+.cs-error { color: var(--dsw-alias-state-error-primary); font-size: 12px; }
+.cs-warn { color: var(--dsw-alias-state-warning-primary, var(--dsw-alias-label-secondary)); font-size: 12px; line-height: 18px; }
+.cs-input {
+  box-sizing: border-box; padding: 6px 10px; border-radius: 8px; min-width: 200px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  background: var(--dsw-alias-bg-layer-1);
+  color: var(--dsw-alias-label-primary);
+  font: inherit; font-size: 13px;
+}
+.cs-target { font-size: 13px; color: var(--dsw-alias-label-primary); line-height: 30px; }
+.cs-table-wrap {
+  max-height: 460px; overflow: auto; margin-bottom: 12px;
+  border: 1px solid var(--dsw-alias-border-l2); border-radius: 8px;
+}
+.cs-table { width: 100%; border-collapse: separate; border-spacing: 0; font-size: 12px; }
+.cs-table th {
+  position: sticky; top: 0; z-index: 1;
+  text-align: left; font-weight: 500; color: var(--dsw-alias-label-secondary);
+  background: var(--dsw-alias-bg-layer-1);
+  padding: 6px 8px; border-bottom: 1px solid var(--dsw-alias-border-l2); white-space: nowrap;
+}
+.cs-table td {
+  padding: 6px 8px; border-bottom: 1px solid var(--dsw-alias-border-l2);
+  color: var(--dsw-alias-label-primary); vertical-align: top;
+}
+.cs-table tr:last-child td { border-bottom: none; }
+.cs-row--changed td { background: var(--dsw-alias-bg-layer-2, transparent); }
+.cs-id { font-variant-numeric: tabular-nums; word-break: break-all; }
+.cs-dim { color: var(--dsw-alias-label-tertiary); }
+.cs-change { white-space: nowrap; }
+.cs-from { color: var(--dsw-alias-label-tertiary); text-decoration: line-through; }
+.cs-badge {
+  display: inline-block; padding: 0 6px; border-radius: 9px; font-size: 11px; line-height: 18px;
+  border: 1px solid var(--dsw-alias-border-l2); color: var(--dsw-alias-label-secondary);
+}
+.cs-badge--image { border-color: var(--dsw-alias-brand-primary); color: var(--dsw-alias-brand-primary); }
+.cs-unmatched { margin: 8px 0 0; padding-left: 18px; color: var(--dsw-alias-label-tertiary); font-size: 12px; }
+`
+
+/**
+ * Register the copy dictionary, the section styles, and the section itself.
+ * @param ctx - browser root context.
+ */
+export function apply(ctx: ClientContext): void {
+  ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'model-capability-sync: copy dictionaries')
+
+  if (typeof document !== 'undefined') {
+    ctx.effect(() => {
+      const element = document.createElement('style')
+      element.textContent = SECTION_CSS
+      document.head.append(element)
+      return () => { element.remove() }
+    }, 'model-capability-sync: section styles')
+  }
+
+  const connection = ctx.get('connection') as ConnectionFace
+  const remote = ctx.get('remote') as RemoteFace
+  const t = ctx.locale.bind(NS)
+
+  const injected = (): SyncSectionInjected => ({
+    preview: request =>
+      connection.rpc.call(CHANNEL, 'preview', request) as Promise<RpcEnvelope<PreviewResponse>>,
+    live: request =>
+      connection.rpc.call(CHANNEL, 'live', request) as Promise<RpcEnvelope<LiveResponse>>,
+    describeSettings: async () => namespacesOf(await remote.settings.describe()),
+    mutateSettings: async (ns, ops, expectedRevision) => {
+      const view = unwrap(await remote.settings.mutate(ns, ops, expectedRevision)) as SettingsDescriptor | undefined
+      if (view === undefined) throw new Error('settings.mutate returned no namespace view')
+      return view
+    },
+  })
+
+  ctx.slots.inject('settings.section', () => ctx.slots.register({
+    name: 'settings.section',
+    id: 'model-capability-sync',
+    order: 16,
+    label: () => t('nav'),
+    locale: NS,
+    inject: injected,
+  }, SyncSection))
+}

package/src/client/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Browser-half entry: the module loader imports this file and calls its
+ * `apply` once the injected services exist.
+ * @module dsh-model-capability-sync/client
+ */
+export { apply, inject } from './apply.ts'

package/src/client/locale.ts

@@ -0,0 +1,124 @@
+/**
+ * Copy dictionaries for the capability-sync section. Chinese first (the dsh
+ * web convention); English mirrors it key for key.
+ */
+
+export const zh = {
+  nav: '模型能力同步',
+  loading: '正在读取配置…',
+  intro: '从 models.dev 查询已配置模型的能力（上下文窗口、输出上限、是否支持图片、推理档位），并写入所选供应商的配置。本页只写配置，不发送任何推理请求。',
+  writeTarget: '写入位置',
+  sourceNative: '原生配置',
+  sourcePlugin: '插件配置',
+  nameLlmPiAi: 'pi-ai 适配器',
+  nameLlmDeepseek: 'DeepSeek 官方',
+  nameLlmDeepseekAccount: 'DeepSeek 账号',
+  nameLlmNewapi: 'NewAPI',
+  provider: '供应商',
+  modelCount: '共 {count} 个模型',
+  willSort: '写入时按「前缀分组 + 名称」排序',
+  search: '搜索模型 ID 或目录 ID',
+  onlyChanged: '只看有变化的',
+  changeSummary: '将修改 {rows} 行 · {fields} 个字段',
+  noChanges: '没有需要写入的变化（目录值与你现有配置一致）。',
+  filteredEmpty: '没有符合筛选条件的模型。',
+  fieldEmpty: '未设置',
+  conflictReload: '配置已被其他改动更新，已重新读取最新值；请确认后再点一次「应用」。',
+  analyze: '分析能力',
+  analyzing: '正在匹配…',
+  refreshCatalog: '重新下载目录',
+  apply: '应用',
+  applying: '正在写入…',
+  applied: '已写入 {count} 个模型',
+  overwrite: '覆盖已有值',
+  overwriteHint: '不勾选时只填空白字段，你手填过的值不会被改写。',
+  selectAll: '全选',
+  colModel: '模型 ID',
+  colMatch: '匹配',
+  colContext: '上下文',
+  colOutput: '输出',
+  colImage: '图片',
+  colLive: '当前生效',
+  colLiveHint: '由真正接管这条路由的适配器上报，也就是聊天请求实际看到的值。若它与「图片」列不一致，说明配置被另一个插件抢占了路由。',
+  liveError: '无法读取',
+  liveSummary: '当前生效：{image} 个支持图片，{text} 个纯文本。若与「图片」列不一致，说明这条路由由别的插件接管，写入本配置不会生效。',
+  colReasoning: '推理档位',
+  imageYes: '支持',
+  imageNo: '纯文本',
+  unmatched: '未匹配',
+  unmatchedHint: '这些模型在 models.dev 里找不到，保持原样。可在别名表里手动指定。',
+  noModels: '该供应商下还没有模型。',
+  noTarget: '没有找到可写的配置条目（需要已启用的 llm-pi-ai 供应商配置）。',
+  loadFailed: '加载失败',
+  retry: '重试',
+  viaAlias: '别名',
+  viaExact: '精确',
+  viaFolded: '忽略大小写',
+  viaBasename: '去前缀',
+  viaSuffix: '去变体后缀',
+  catalogInfo: '目录：{models} 个模型 · {time}',
+  catalogStale: '在线目录下载失败，正在使用本机缓存（{time}）。数据可能不是最新，字段含义不变。',
+  nothingSelected: '没有选中任何模型。',
+  done: '完成。',
+} as const
+
+export type SyncKey = keyof typeof zh
+
+export const en: Record<SyncKey, string> = {
+  nav: 'Model capabilities',
+  loading: 'Reading configuration…',
+  intro: 'Look up capabilities (context window, output cap, image input, reasoning efforts) for the models already configured here, then write them into the selected provider. This page only writes configuration; it never sends a model request.',
+  writeTarget: 'Write to',
+  sourceNative: 'Built in',
+  sourcePlugin: 'Plugin',
+  nameLlmPiAi: 'pi-ai adapter',
+  nameLlmDeepseek: 'DeepSeek official',
+  nameLlmDeepseekAccount: 'DeepSeek account',
+  nameLlmNewapi: 'NewAPI',
+  provider: 'Provider',
+  modelCount: '{count} models',
+  willSort: 'Written sorted by vendor prefix, then name',
+  search: 'Search model id or catalog id',
+  onlyChanged: 'Only rows that change',
+  changeSummary: 'Will change {rows} rows · {fields} fields',
+  noChanges: 'Nothing to write: the catalog agrees with your configuration.',
+  filteredEmpty: 'No model matches the filter.',
+  fieldEmpty: 'unset',
+  conflictReload: 'The configuration changed elsewhere; the latest values were reloaded. Check them, then press Apply again.',
+  analyze: 'Analyze',
+  analyzing: 'Matching…',
+  refreshCatalog: 'Re-download catalog',
+  apply: 'Apply',
+  applying: 'Writing…',
+  applied: 'Wrote {count} models',
+  overwrite: 'Overwrite existing values',
+  overwriteHint: 'Unchecked: only blank fields are filled, so values you typed are preserved.',
+  selectAll: 'Select all',
+  colModel: 'Model id',
+  colMatch: 'Match',
+  colContext: 'Context',
+  colOutput: 'Output',
+  colImage: 'Image',
+  colLive: 'In effect',
+  colLiveHint: 'Reported by the adapter that actually serves this route — what a chat request sees. A value that disagrees with the Image column means another plugin owns the route.',
+  liveError: 'unreadable',
+  liveSummary: 'In effect: {image} image-capable, {text} text-only. If this disagrees with the Image column, another plugin serves the route and writing this entry changes nothing.',
+  colReasoning: 'Reasoning',
+  imageYes: 'yes',
+  imageNo: 'text only',
+  unmatched: 'unmatched',
+  unmatchedHint: 'These ids are absent from models.dev and stay untouched. Add an alias to map them by hand.',
+  noModels: 'This provider has no models yet.',
+  noTarget: 'No writable configuration entry found (an enabled llm-pi-ai provider is required).',
+  loadFailed: 'Load failed',
+  retry: 'Retry',
+  viaAlias: 'alias',
+  viaExact: 'exact',
+  viaFolded: 'case-folded',
+  viaBasename: 'basename',
+  viaSuffix: 'suffix',
+  catalogInfo: 'Catalog: {models} models · {time}',
+  catalogStale: 'The online catalog download failed; using the local copy from {time}. The facts still mean the same thing, they may just be older.',
+  nothingSelected: 'Nothing selected.',
+  done: 'Done.',
+}

package/src/index.ts

@@ -0,0 +1,148 @@
+/**
+ * Host half: one RPC channel that answers "what does the catalog say about
+ * these model ids?".
+ *
+ * The plugin registers no LLM provider route on purpose — it only supplies
+ * facts. The browser half decides which provider entry to write and performs
+ * the write through the official settings service, so this half never touches
+ * configuration.
+ * @module dsh-model-capability-sync
+ */
+import { loadCatalog } from './catalog.ts'
+import type { Catalog } from './catalog.ts'
+import { capabilitiesOf } from './mapping.ts'
+import { matchModel } from './match.ts'
+import type { LiveRequest, LiveResponse, LiveRow, PreviewRequest, PreviewResponse, PreviewRow, RpcEnvelope } from './types.ts'
+
+/** Cordis plugin name; the profile entry id matches. */
+export const name = 'model-capability-sync'
+
+/** The channel is served over the web server, so both services are required. */
+export const inject = ['connection', 'webServer', 'llm']
+
+/** Own RPC channel; the browser half calls this exact path. */
+const CHANNEL = '/model-capability-sync'
+
+/** The slice of the host context this plugin uses. */
+interface HostContext {
+  get(service: string): unknown
+  effect(callback: () => (() => void | Promise<void>) | void, label?: string): void
+  logger: { warn(message: string): void; error(message: unknown): void }
+}
+
+type Handler = (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<RpcEnvelope<unknown>>
+
+/** The connection service's owner-taking registration (see DESIGN in llm-newapi). */
+interface Registrar {
+  register(owner: unknown, channel: string, handler: Handler): () => Promise<void>
+}
+
+/** Resolve one id against the catalog into a preview row. */
+function previewOne(catalog: Catalog, id: string, aliases: Readonly<Record<string, string>>): PreviewRow {
+  const match = matchModel(catalog, id, aliases)
+  if (match === undefined) return { id, reason: 'not in the models.dev catalog' }
+  const entry = catalog.byId.get(match.modelId)?.find(candidate => candidate.provider === match.provider)
+  if (entry === undefined) return { id, match, reason: 'catalog entry vanished between match and read' }
+  const fields = capabilitiesOf(entry)
+  if (Object.keys(fields).length === 0) return { id, match, reason: 'catalog entry states no capability facts' }
+  return { id, match, fields }
+}
+
+/** Serve one `preview` request. */
+async function preview(request: PreviewRequest, signal: AbortSignal): Promise<PreviewResponse> {
+  const ids = Array.isArray(request.ids) ? request.ids.filter(id => typeof id === 'string' && id.length > 0) : []
+  const catalog = await loadCatalog({ refresh: request.refresh === true, proxyUrl: request.proxyUrl }, signal)
+  const aliases = request.aliases ?? {}
+  return {
+    fetchedAt: catalog.fetchedAt,
+    catalogModels: catalog.modelCount,
+    ...catalog.stale === true ? { stale: true } : {},
+    rows: ids.map(id => previewOne(catalog, id, aliases)),
+  }
+}
+
+/** One RPC envelope, never a thrown value: the transport would turn that into an opaque 500. */
+function failure(message: string): RpcEnvelope<never> {
+  return { ok: false, error: { code: 'internal', message, details: {} } }
+}
+
+/** The LLM registry face this half reads live model metadata through. */
+interface LlmFace {
+  resolveModelInfo(provider: string, model: string, signal?: AbortSignal): Promise<{
+    inputModalities?: readonly string[]
+    context?: { contextWindow: number }
+    defaultMaxTokens?: number
+  }>
+}
+
+/**
+ * Read what the adapter that owns `provider` reports right now.
+ *
+ * A configuration entry and the route a chat request takes can disagree: two
+ * plugins may claim one provider route, and only the first registration serves
+ * it. This answer is what a request would see, so a filled-in `input` that
+ * never takes effect becomes visible instead of inferred.
+ * @param llm - the LLM registry.
+ * @param request - route and model ids to resolve.
+ * @param signal - cancellation for adapter-owned lookups.
+ * @returns one row per requested id, in request order.
+ */
+async function live(llm: LlmFace, request: LiveRequest, signal: AbortSignal): Promise<LiveResponse> {
+  const provider = typeof request.provider === 'string' ? request.provider : ''
+  const ids = Array.isArray(request.ids) ? request.ids.filter(id => typeof id === 'string' && id.length > 0) : []
+  const rows: LiveRow[] = []
+  for (const id of ids) {
+    try {
+      const info = await llm.resolveModelInfo(provider, id, signal)
+      rows.push({
+        id,
+        ...info.inputModalities === undefined ? {} : { input: [...info.inputModalities] },
+        ...info.context === undefined ? {} : { contextWindow: info.context.contextWindow },
+        ...info.defaultMaxTokens === undefined ? {} : { maxTokens: info.defaultMaxTokens },
+      })
+    } catch (error) {
+      rows.push({ id, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+  return { rows }
+}
+
+/**
+ * Build the channel handler bound to one LLM registry.
+ * @param llm - the LLM registry the `live` endpoint reads through, when present.
+ * @returns the endpoint dispatcher.
+ */
+function createHandler(llm: LlmFace | undefined): Handler {
+  return async (endpoint, payload, signal) => {
+    try {
+      if (endpoint === 'preview') {
+        return { ok: true, value: await preview(payload as PreviewRequest, signal) }
+      }
+      if (endpoint === 'live') {
+        if (llm === undefined) return failure('model-capability-sync: no llm service to resolve the live route')
+        return { ok: true, value: await live(llm, payload as LiveRequest, signal) }
+      }
+      return failure(`model-capability-sync: unknown endpoint ${JSON.stringify(endpoint)}`)
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error))
+    }
+  }
+}
+
+/**
+ * Register the channel. The registration rides the calling fiber, so a plugin
+ * reload removes the route with it.
+ * @param ctx - host context carrying `connection`, `webServer` and `llm`.
+ */
+export function apply(ctx: HostContext): void {
+  const connection = ctx.get('connection')
+  const llm = ctx.get('llm') as LlmFace | undefined
+  if (connection === undefined) {
+    ctx.logger.warn('model-capability-sync: no connection service; the capability channel is unavailable')
+    return
+  }
+  if (llm === undefined) ctx.logger.warn('model-capability-sync: no llm service; the live route check is unavailable')
+  const registrar = connection as Registrar
+  const handler = createHandler(llm)
+  ctx.effect(() => registrar.register(ctx, CHANNEL, handler), 'model-capability-sync: RPC channel')
+}

package/src/mapping.ts

@@ -0,0 +1,71 @@
+/**
+ * Turning one catalog entry into the capability fields a provider model entry
+ * accepts.
+ *
+ * Everything here is a pure function of catalog data: no gateway call, no
+ * guessing beyond the catalog's own facts. A field the catalog does not state
+ * stays absent, so the writer never invents a value.
+ * @module dsh-model-capability-sync/mapping
+ */
+import type { CatalogEntry } from './catalog.ts'
+import type { CapabilityFields, Modality } from './types.ts'
+
+/** Thinking levels the harness recognizes, strongest last. */
+const THINKING_LEVELS = new Set(['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'])
+
+/** A positive integer or nothing. */
+function positive(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.round(value) : undefined
+}
+
+/** Map the catalog's media list onto the harness's two modalities. */
+function modalitiesOf(entry: CatalogEntry): Modality[] | undefined {
+  const declared = entry.model.modalities?.input
+  if (declared === undefined) return undefined
+  const accepted: Modality[] = []
+  for (const media of declared) {
+    if (media === 'image' && !accepted.includes('image')) accepted.push('image')
+  }
+  // A model that lists only images still reads text in practice; the harness
+  // always sends text, so `text` is never dropped.
+  return ['text', ...accepted]
+}
+
+/**
+ * Build the reasoning-effort map from the catalog's `effort` option.
+ * @returns the dict, `false` when the catalog says the model cannot reason, or
+ *   `undefined` when the catalog is silent.
+ */
+function reasoningOf(entry: CatalogEntry): Record<string, string> | false | undefined {
+  const model = entry.model
+  if (model.reasoning === false) return false
+  const option = model.reasoning_options?.find(candidate => candidate.type === 'effort')
+  const values = option?.values ?? []
+  const efforts: Record<string, string> = {}
+  for (const value of values) {
+    if (typeof value !== 'string') continue
+    if (!THINKING_LEVELS.has(value)) continue
+    efforts[value] = value
+  }
+  return Object.keys(efforts).length > 0 ? efforts : undefined
+}
+
+/**
+ * Read every capability the catalog states for one entry.
+ *
+ * The catalog's display name is deliberately not returned: this plugin fills
+ * facts, it never renames a model entry.
+ * @param entry - the matched catalog entry.
+ * @returns only the fields the catalog actually declares.
+ */
+export function capabilitiesOf(entry: CatalogEntry): CapabilityFields {
+  const model = entry.model
+  const input = modalitiesOf(entry)
+  const reasoningEfforts = reasoningOf(entry)
+  return {
+    ...positive(model.limit?.context) === undefined ? {} : { contextWindow: positive(model.limit?.context) as number },
+    ...positive(model.limit?.output) === undefined ? {} : { maxTokens: positive(model.limit?.output) as number },
+    ...input === undefined ? {} : { input },
+    ...reasoningEfforts === undefined ? {} : { reasoningEfforts },
+  }
+}