@kabmo-labs/kabmo 0.0.0-stage → 0.0.1

package/src/server/lib/models/provider-items.server.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The two ProviderItem shapes the registry builds from omp's own config files
+ * rather than from a live RPC probe: a models.yml entry, and a provider omp
+ * reports as disabled in config.yml.
+ *
+ * Split from `provider-registry.server.ts` because these are the payload the
+ * settings UI actually reads — a field dropped here is invisible until the
+ * control it gates stops working, which is how a missing `baseUrl` disabled
+ * "fetch models" for every models.yml provider without an error anywhere.
+ */
+
+import {
+  isOmpProviderApi,
+  isProviderAuthMode,
+  isProviderDiscoveryType,
+} from '@/shared/lib/models/provider/dialect';
+import { removeLegacyKenariModels } from '@/shared/lib/models/provider/cleanup';
+import { formatContextWindow } from '@/shared/lib/code/format';
+import type { NativeProviderInfo } from '@/server/lib/omp/config/models-config';
+import type { ProviderItem } from '@/shared/types';
+
+/**
+ * Build a disabled-native ProviderItem for a provider the omp agent reports as
+ * disabled (config.yml disabledProviders). The UI treats these as
+ * "disconnected" — re-enabling via POST { enableProvider } flips config.yml.
+ */
+export function disabledProviderItem(slug: string): ProviderItem {
+  return {
+    id: `omp-disabled-${slug}`,
+    name: slug,
+    slug,
+    icon: slug,
+    status: 'disconnected',
+    disabled: true,
+    configuredIn: 'omp disabledProviders',
+    models: [],
+  };
+}
+
+/**
+ * Native provider entry discovered from models.yml. Credentials never leave
+ * omp's own stores — Kabmo only surfaces registration info.
+ */
+export function nativeProviderItem(info: NativeProviderInfo, isDisabled = false): ProviderItem {
+  const { slug, baseUrl } = info;
+  const models = info.models.map((model) => ({
+    id: model.id,
+    name: model.name || model.id,
+    contextWindow: model.contextWindow
+      ? `${formatContextWindow(model.contextWindow) || Math.round(model.contextWindow / 1000)} ctx`
+      : '',
+    hasTools: true,
+    hasVision: model.imageInput === true,
+    hasReasoning: model.reasoning,
+    isVisible: true,
+    maxTokens: model.maxTokens,
+  }));
+  return {
+    id: `omp-native-${slug}`,
+    name: slug,
+    slug,
+    icon: slug,
+    status: isDisabled ? 'disconnected' : 'connected',
+    disabled: isDisabled,
+    configuredIn: baseUrl ? `models.yml · ${baseUrl}` : 'models.yml',
+    credentialSource: 'models.yml' as const,
+    // The endpoint travels on the item, not only inside `configuredIn`'s label.
+    // It is what the models list gates "fetch models" on, so leaving it out of
+    // the payload disabled the button for every models.yml provider — the one
+    // set of providers whose endpoint is actually known to Kabmo. The
+    // URL is not a secret: `configuredIn` already prints it.
+    ...(baseUrl ? { baseUrl } : {}),
+    // This entry was built FROM models.yml, so the file holds it by definition.
+    inModelsYml: true,
+    // The dialect is what makes a native entry legible in the settings UI: an
+    // Anthropic-shaped proxy and an OpenAI one look identical without it, and
+    // the keyless/auth choice decides whether a missing credential is a bug.
+    ...(isOmpProviderApi(info.api) ? { api: info.api } : {}),
+    ...(isProviderAuthMode(info.auth) ? { auth: info.auth } : {}),
+    ...(isProviderDiscoveryType(info.discovery) ? { discovery: info.discovery } : {}),
+    // The registry can tell the two shapes apart without guessing: a
+    // discovery block means omp owns the list, and no models at all under a
+    // configured endpoint means this is an override for a bundled provider.
+    modelSource: isProviderDiscoveryType(info.discovery)
+      ? 'discovery'
+      : info.models.length === 0 && Boolean(baseUrl)
+        ? 'override'
+        : 'fetch',
+    models: removeLegacyKenariModels({ name: slug, slug, baseUrl }, models),
+  };
+}

package/src/server/lib/models/provider-listing.server.test.ts

@@ -0,0 +1,283 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `provider-listing.server.ts` probes a provider endpoint for its model list,
+ * and the probe is the one place Kabmo picks a wire dialect on the
+ * user's behalf. Each rule here was a real failure mode:
+ *
+ *  - an Anthropic-shaped endpoint rejects a Bearer header with a 401 that reads
+ *    like a bad key, so the dialect must pick `x-api-key` + `anthropic-version`;
+ *  - Azure takes a string key as `api-key` and the version as a query
+ *    parameter — a Bearer probe there is always a 401;
+ *  - Gemini wants the key in the query string;
+ *  - a dialect with no listing route at all (Bedrock, Vertex, Codex, the judge
+ *    APIs) must return an empty list WITHOUT probing, or a 404 is reported as
+ *    if the endpoint were broken;
+ *  - with no dialect the three styles are tried in order, and the first
+ *    recognizable list wins — that is what makes the picker work for a gateway
+ *    nobody classified.
+ *
+ * A local stub server records the exact headers and URL of every request, so
+ * each assertion is about what actually went on the wire.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+
+import { enrichFromCatalog, fetchRemoteModels, toOmpSeed } from '@/server/lib/models/provider-listing.server';
+
+/**
+ * The runner's own fetch, captured before any test runs: another file in the
+ * same `bun test` process may have left a stub on the global, and this file
+ * must reach the REAL listener it starts per case.
+ */
+/** The runner's own fetch, reached through `Bun` so a stub leaked onto the global cannot be mistaken for it. */
+const realFetch = Bun.fetch;
+
+interface RecordedRequest {
+  url: string;
+  headers: Headers;
+}
+
+const servers: Bun.Server<undefined>[] = [];
+const requests: RecordedRequest[] = [];
+const MODELS_BODY = { data: [{ id: 'm1', name: 'M1' }] };
+
+function startServer(respond: (request: Request, index: number) => Response): string {
+  const server = Bun.serve({
+    port: 0,
+    hostname: '127.0.0.1',
+    fetch(request) {
+      const index = requests.length;
+      requests.push({ url: request.url, headers: new Headers(request.headers) });
+      return respond(request, index);
+    },
+  });
+  servers.push(server);
+  return `http://127.0.0.1:${server.port}`;
+}
+
+beforeEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+afterEach(() => {
+  for (const server of servers.splice(0)) server.stop(true);
+  requests.length = 0;
+  globalThis.__kabmoModelsDevCatalog = undefined;
+});
+
+describe('fetchRemoteModels — one dialect, one header set', () => {
+  test('anthropic-messages sends x-api-key and anthropic-version, never a Bearer', async () => {
+    const base = startServer(() => Response.json(MODELS_BODY));
+    const result = await fetchRemoteModels(base, 'sk-ant', 'anthropic-messages');
+
+    expect(result.models?.map((model) => model.id)).toEqual(['m1']);
+    expect(result.error).toBe('');
+    expect(requests).toHaveLength(1);
+    expect(requests[0].url).toBe(`${base}/models`);
+    expect(requests[0].headers.get('x-api-key')).toBe('sk-ant');
+    expect(requests[0].headers.get('anthropic-version')).toBe('2023-06-01');
+    expect(requests[0].headers.get('authorization')).toBeNull();
+  });
+
+  test('a keyless anthropic endpoint still announces the version', async () => {
+    const base = startServer(() => Response.json(MODELS_BODY));
+    await fetchRemoteModels(base, undefined, 'anthropic-messages');
+
+    expect(requests[0].headers.get('x-api-key')).toBeNull();
+    expect(requests[0].headers.get('anthropic-version')).toBe('2023-06-01');
+  });
+
+  test('OpenAI-compatible dialects send the Bearer header only', async () => {
+    for (const api of ['openai-completions', 'openai-responses'] as const) {
+      requests.length = 0;
+      const base = startServer(() => Response.json(MODELS_BODY));
+      await fetchRemoteModels(base, 'sk-oi', api);
+
+      expect(requests[0].headers.get('authorization')).toBe('Bearer sk-oi');
+      expect(requests[0].headers.get('x-api-key')).toBeNull();
+    }
+  });
+
+  test('gemini carries the key percent-encoded in the query string, with no auth header', async () => {
+    const base = startServer(() => Response.json({ models: [{ id: 'models/gemini-2', displayName: 'Gemini 2' }] }));
+    const result = await fetchRemoteModels(base, 'a/b+c', 'google-generative-ai');
+
+    expect(result.models?.map((model) => model.id)).toEqual(['gemini-2']);
+    expect(requests[0].url).toBe(`${base}/models?key=a%2Fb%2Bc`);
+    expect(requests[0].headers.get('authorization')).toBeNull();
+    expect(requests[0].headers.get('x-api-key')).toBeNull();
+  });
+
+  test('azure sends api-key and api-version, never a Bearer', async () => {
+    const base = startServer(() => Response.json(MODELS_BODY));
+    await fetchRemoteModels(base, 'azure-key', 'azure-openai-responses');
+
+    expect(requests[0].url).toBe(`${base}/models?api-version=v1`);
+    expect(requests[0].headers.get('api-key')).toBe('azure-key');
+    expect(requests[0].headers.get('authorization')).toBeNull();
+  });
+
+  test('a dialect with no listing route answers an empty list without probing', async () => {
+    for (const api of ['bedrock-converse-stream', 'google-vertex', 'openai-codex-responses', 'openrouter-decisions'] as const) {
+      const result = await fetchRemoteModels('http://127.0.0.1:1', 'key', api);
+      expect(result).toEqual({ models: [], error: '' });
+    }
+    expect(requests).toHaveLength(0);
+  });
+
+  test('trailing slashes on the base url are not doubled', async () => {
+    const base = startServer(() => Response.json(MODELS_BODY));
+    await fetchRemoteModels(`${base}///`, 'sk', 'openai-completions');
+    expect(requests[0].url).toBe(`${base}/models`);
+  });
+});
+
+describe('fetchRemoteModels — unclassified endpoints and failures', () => {
+  test('no dialect tries the Bearer style first and stops at the first hit', async () => {
+    const base = startServer(() => Response.json(MODELS_BODY));
+    const result = await fetchRemoteModels(base, 'sk-any', undefined);
+
+    expect(result.models?.map((model) => model.id)).toEqual(['m1']);
+    expect(requests).toHaveLength(1);
+    expect(requests[0].headers.get('authorization')).toBe('Bearer sk-any');
+  });
+
+  test('no dialect falls back to the anthropic style when the first body is unrecognizable', async () => {
+    const base = startServer((_request, index) => (
+      index === 0 ? new Response('not a model list', { status: 200 }) : Response.json(MODELS_BODY)
+    ));
+    const result = await fetchRemoteModels(base, 'sk-any', undefined);
+
+    expect(result.models?.map((model) => model.id)).toEqual(['m1']);
+    expect(requests).toHaveLength(2);
+    expect(requests[1].headers.get('x-api-key')).toBe('sk-any');
+  });
+
+  test('a keyless unclassified endpoint tries the Bearer style once', async () => {
+    const base = startServer(() => new Response('nope', { status: 200 }));
+    const result = await fetchRemoteModels(base, undefined, undefined);
+
+    expect(requests).toHaveLength(1);
+    expect(result.models).toBeNull();
+    expect(result.error).toBe('Failed to fetch models — OpenAI-compatible: unrecognized response format');
+  });
+
+  test('a non-2xx response is reported with its status', async () => {
+    const base = startServer(() => new Response('unauthorized', { status: 401 }));
+    const result = await fetchRemoteModels(base, 'sk-bad', 'openai-completions');
+
+    expect(result.models).toBeNull();
+    expect(result.error).toBe('Failed to fetch models — OpenAI-compatible: HTTP 401');
+  });
+
+  test('a dead endpoint reports the transport failure without retrying other styles', async () => {
+    const base = startServer(() => Response.json(MODELS_BODY));
+    servers.pop()?.stop(true);
+    const result = await fetchRemoteModels(base, 'sk-any', undefined);
+
+    expect(result.models).toBeNull();
+    expect(result.error.startsWith('Failed to fetch models — OpenAI-compatible: ')).toBe(true);
+    expect(requests).toHaveLength(0);
+  });
+});
+
+describe('enrichFromCatalog', () => {
+  const catalog = {
+    openai: {
+      models: {
+        'gpt-5': {
+          name: 'GPT-5',
+          attachment: true,
+          reasoning: true,
+          tool_call: true,
+          limit: { context: 128_000, output: 16_384 },
+          cost: { input: 1.25, output: 10, cache_read: 0.125 },
+        },
+      },
+    },
+  };
+
+  test('a bare listing entry is filled in from the catalog', async () => {
+    globalThis.__kabmoModelsDevCatalog = { data: catalog, expiresAt: Date.now() + 3_600_000 };
+    const [model] = await enrichFromCatalog([
+      { id: 'gpt-5', name: 'gpt-5', contextWindow: '', hasTools: false, hasVision: false, isVisible: true },
+    ], 'openai');
+
+    expect(model.name).toBe('Gpt-5');
+    expect(model.contextWindow).toBe('128K ctx · 16K out');
+    expect(model.hasVision).toBe(true);
+    expect(model.hasReasoning).toBe(true);
+    expect(model.hasTools).toBe(true);
+    expect(model.priceInput).toBe(1.25);
+    expect(model.priceOutput).toBe(10);
+    expect(model.priceCacheRead).toBe(0.125);
+    expect(model.priceCacheWrite).toBeUndefined();
+  });
+
+  test('the provider-reported metadata (context, pricing) survives enrichment', async () => {
+    globalThis.__kabmoModelsDevCatalog = { data: catalog, expiresAt: Date.now() + 3_600_000 };
+    const [model] = await enrichFromCatalog([
+      { id: 'gpt-5', name: 'My GPT', contextWindow: '8K ctx', hasTools: true, hasVision: true, isVisible: true, priceInput: 0.5 },
+    ], 'openai');
+
+    expect(model.name).toBe('Gpt-5');
+    expect(model.contextWindow).toBe('8K ctx');
+    expect(model.priceInput).toBe(0.5);
+    expect(model.priceOutput).toBe(10);
+  });
+
+  test('an empty catalog leaves the models untouched', async () => {
+    globalThis.__kabmoModelsDevCatalog = { data: {}, expiresAt: Date.now() + 3_600_000 };
+    const models = [{ id: 'gpt-5', name: 'gpt-5', contextWindow: '', hasTools: false, hasVision: false, isVisible: true }];
+    expect(await enrichFromCatalog(models, 'openai')).toBe(models);
+  });
+
+  test('a model the catalog does not know is passed through by reference', async () => {
+    globalThis.__kabmoModelsDevCatalog = { data: catalog, expiresAt: Date.now() + 3_600_000 };
+    const unknown = { id: 'unknown-model', name: 'unknown-model', contextWindow: '', hasTools: false, hasVision: false, isVisible: true };
+    const [model] = await enrichFromCatalog([unknown], 'openai');
+    expect(model).toBe(unknown);
+  });
+});
+
+describe('toOmpSeed', () => {
+  test('context and output labels parse back to tokens', () => {
+    expect(toOmpSeed({
+      id: 'm', name: 'm', contextWindow: '1M ctx · 384K out', hasTools: true, hasVision: false, isVisible: true,
+    })).toEqual({ id: 'm', contextWindow: 1_000_000, maxTokens: 384_000 });
+  });
+
+  test('a cost is seeded only when both sides are known, cache rates defaulting to 0', () => {
+    expect(toOmpSeed({
+      id: 'm', name: 'm', contextWindow: '', hasTools: true, hasVision: false, isVisible: true,
+      priceInput: 1.5, priceOutput: 6,
+    })).toEqual({ id: 'm', cost: { input: 1.5, output: 6, cacheRead: 0, cacheWrite: 0 } });
+
+    expect(toOmpSeed({
+      id: 'm', name: 'm', contextWindow: '', hasTools: true, hasVision: false, isVisible: true, priceInput: 1.5,
+    })).toEqual({ id: 'm' });
+  });
+
+  test('a non-finite price never reaches the file', () => {
+    expect(toOmpSeed({
+      id: 'm', name: 'm', contextWindow: '', hasTools: true, hasVision: false, isVisible: true,
+      priceInput: Number.POSITIVE_INFINITY, priceOutput: 6,
+    })).toEqual({ id: 'm' });
+  });
+
+  test('flags and a distinct name are carried through, the id-only name is dropped', () => {
+    expect(toOmpSeed({
+      id: 'm', name: 'M', contextWindow: '200K ctx', hasTools: true, hasVision: true, hasReasoning: true, isVisible: true,
+    })).toEqual({ id: 'm', name: 'M', reasoning: true, imageInput: true, contextWindow: 200_000 });
+  });
+
+  test('an unparseable context label yields no window fields', () => {
+    expect(toOmpSeed({
+      id: 'm', name: 'm', contextWindow: 'plenty', hasTools: true, hasVision: false, isVisible: true,
+    })).toEqual({ id: 'm' });
+  });
+});

package/src/server/lib/models/provider-listing.server.ts

@@ -0,0 +1,279 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The model-listing probe behind the providers settings auto-fetch.
+ *
+ * A provider endpoint can be asked for its models in a handful of shapes, and
+ * which one it answers depends on the WIRE DIALECT it speaks: an
+ * Anthropic-shaped proxy rejects a Bearer header, a Gemini endpoint wants the
+ * key in the query string, and a dialect with no listing route at all (Bedrock,
+ * Vertex, Codex, the judge APIs) answers nothing. The probe therefore follows
+ * the dialect when the caller knows it, and only falls back to trying the three
+ * common styles when the endpoint is unclassified.
+ *
+ * Server-only: it performs the outbound HTTP the settings page must not.
+ */
+
+import { extractModels } from '@/shared/lib/models/remote-list';
+import { findCatalogModel, loadModelsDevCatalog } from '@/shared/lib/models/catalog';
+import type { OmpProviderApi } from '@/shared/types/settings/provider';
+import type { ProviderModel } from '@/shared/types';
+
+const FETCH_TIMEOUT_MS = 15_000;
+const ANTHROPIC_VERSION = '2023-06-01';
+/** omp's own Azure default (`DEFAULT_AZURE_API_VERSION` in pi-ai). */
+const AZURE_API_VERSION = 'v1';
+
+export interface FetchAttempt {
+  models: ProviderModel[] | null;
+  error: string;
+}
+
+async function attemptStyle(
+  label: string,
+  url: string,
+  headers: Record<string, string>,
+): Promise<FetchAttempt> {
+  const response = await fetch(url, { headers, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+  let payload: unknown = null;
+  try {
+    payload = await response.json();
+  } catch {
+    // Non-JSON body (HTML error page, empty body) — payload stays null and is
+    // reported below as an unrecognized response format.
+  }
+  if (response.status < 200 || response.status >= 300) {
+    return { models: null, error: `${label}: HTTP ${response.status}` };
+  }
+  const models = extractModels(payload);
+  if (!models) return { models: null, error: `${label}: unrecognized response format` };
+  return { models, error: '' };
+}
+
+/**
+ * Listing probe for one dialect, or `null` when the dialect has no listing
+ * route to probe at all. Bedrock, Vertex, Codex, Gemini-CLI and the two judge
+ * APIs are reached through non-`/models` protocols (SigV4, gcloud auth,
+ * ChatGPT's backend, `{baseUrl}/decisions`), so probing `/models` there would
+ * report a 404 as if the endpoint were broken. Those providers are registered
+ * with an empty list instead.
+ */
+function listingAttempts(
+  base: string,
+  apiKey: string | undefined,
+  api: OmpProviderApi,
+): Array<{ label: string; url: string; headers: Record<string, string> }> | null {
+  switch (api) {
+    case 'anthropic-messages':
+      return [{
+        label: 'Anthropic',
+        url: `${base}/models`,
+        headers: { 'anthropic-version': ANTHROPIC_VERSION, ...(apiKey ? { 'x-api-key': apiKey } : {}) },
+      }];
+    case 'google-generative-ai':
+      return [{
+        label: 'Gemini',
+        url: apiKey ? `${base}/models?key=${encodeURIComponent(apiKey)}` : `${base}/models`,
+        headers: {},
+      }];
+    case 'openai-completions':
+    case 'openai-responses':
+      return [{
+        label: 'OpenAI-compatible',
+        url: `${base}/models`,
+        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      }];
+    case 'azure-openai-responses':
+      // Azure never takes a bearer: a string key is an `api-key` header, and
+      // the api version rides as a query parameter (omp's own Azure client
+      // builds the request the same way). A Bearer probe there answers 401 and
+      // reads as a bad key.
+      return [{
+        label: 'Azure OpenAI',
+        url: `${base}/models?api-version=${AZURE_API_VERSION}`,
+        headers: apiKey ? { 'api-key': apiKey } : {},
+      }];
+    default:
+      return null;
+  }
+}
+
+/**
+ * Try the styles a DIALECT implies, in order. An explicit dialect from the
+ * request is authoritative — probing an Anthropic endpoint with a Bearer header
+ * would fail with a 401 that reads like a bad key. With no dialect the endpoint
+ * is unclassified, so the three styles are tried and the first recognizable
+ * list wins, which is what makes the picker work for a gateway nobody named.
+ *
+ * A dialect with no listing route yields an empty list and no error: the
+ * provider is still registered, it just cannot be enumerated from here.
+ */
+export async function fetchRemoteModels(
+  baseUrl: string,
+  apiKey: string | undefined,
+  api: OmpProviderApi | undefined,
+): Promise<FetchAttempt> {
+  const base = baseUrl.replace(/\/+$/, '');
+  const attempts: Array<{ label: string; url: string; headers: Record<string, string> }> = [];
+  if (api) {
+    const dialectAttempts = listingAttempts(base, apiKey, api);
+    if (!dialectAttempts) return { models: [], error: '' };
+    attempts.push(...dialectAttempts);
+  } else {
+    attempts.push({
+      label: 'OpenAI-compatible',
+      url: `${base}/models`,
+      headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+    });
+    if (apiKey) {
+      attempts.push({
+        label: 'Anthropic',
+        url: `${base}/models`,
+        headers: { 'x-api-key': apiKey, 'anthropic-version': ANTHROPIC_VERSION },
+      });
+      attempts.push({
+        label: 'Gemini',
+        url: `${base}/models?key=${encodeURIComponent(apiKey)}`,
+        headers: {},
+      });
+    }
+  }
+
+  const errors: string[] = [];
+  for (const attempt of attempts) {
+    try {
+      const result = await attemptStyle(attempt.label, attempt.url, attempt.headers);
+      if (result.models) return result;
+      errors.push(result.error);
+    } catch (error) {
+      // Network-level failure (DNS, refused, timeout) applies to every auth
+      // style — no point retrying the same host with different headers.
+      const message = error instanceof Error ? error.message : 'request failed';
+      errors.push(`${attempt.label}: ${message}`);
+      break;
+    }
+  }
+  return {
+    models: null,
+    error: errors.length > 0 ? `Failed to fetch models — ${errors.join(' · ')}` : 'Failed to fetch models',
+  };
+}
+
+/**
+ * Derive a human-readable display name from a model id.
+ *
+ * - `deepseek-v4-flash-0731:netra` → `Deepseek-V4-Flash-0731 - Netra`
+ * - `deepseek-v4-flash-0731` → `Deepseek-V4-Flash-0731` (title case)
+ */
+function displayNameFromId(modelId: string): string {
+  const colonIdx = modelId.indexOf(':');
+  if (colonIdx >= 0) {
+    const suffix = modelId.slice(colonIdx + 1);
+    if (suffix.length > 0) {
+      const base = modelId.slice(0, colonIdx);
+      const namePart = base.includes('/') ? base.split('/').pop()! : base;
+      const titleBase = namePart.split('-').map(seg => seg.charAt(0).toUpperCase() + seg.slice(1)).join('-');
+      const capSuffix = suffix.charAt(0).toUpperCase() + suffix.slice(1);
+      return `${titleBase} - ${capSuffix}`;
+    }
+  }
+  const name = modelId.includes('/') ? modelId.split('/').pop()! : modelId;
+  return name.split('-').map(seg => seg.charAt(0).toUpperCase() + seg.slice(1)).join('-');
+}
+
+/**
+ * Fill in metadata the listing endpoint did not provide from the models.dev
+ * catalog: vision/reasoning/tool flags, context + output window, and
+ * per-1M-token pricing (cache rates included). Only empty fields are filled —
+ * anything the provider reported itself is kept.
+ */
+export async function enrichFromCatalog(
+  models: ProviderModel[],
+  providerSlug: string | undefined,
+): Promise<ProviderModel[]> {
+  const catalog = await loadModelsDevCatalog();
+  if (!catalog || Object.keys(catalog).length === 0) return models;
+  return models.map((model) => {
+    const match = findCatalogModel(catalog, providerSlug, model.id);
+    if (!match) return model;
+    const { info } = match;
+    const ctx = info.limit?.context;
+    const out = info.limit?.output;
+    const ctxLabel = !model.contextWindow && ctx && ctx > 0
+      ? Math.round(ctx / 1000)
+      : null;
+    const outLabel = out && out > 0 ? Math.round(out / 1000) : null;
+    const catalogContext = ctxLabel
+      ? (outLabel ? `${ctxLabel}K ctx · ${outLabel}K out` : `${ctxLabel}K ctx`)
+      : '';
+    return {
+      ...model,
+      name: displayNameFromId(model.id),
+      contextWindow: model.contextWindow || catalogContext,
+      hasVision: model.hasVision || info.attachment === true,
+      hasReasoning: model.hasReasoning ?? (info.reasoning === true || undefined),
+      hasTools: model.hasTools || info.tool_call === true,
+      priceInput: model.priceInput ?? (typeof info.cost?.input === 'number' ? info.cost.input : undefined),
+      priceOutput: model.priceOutput ?? (typeof info.cost?.output === 'number' ? info.cost.output : undefined),
+      priceCacheRead: model.priceCacheRead
+        ?? (typeof info.cost?.cache_read === 'number' ? info.cost.cache_read : undefined),
+      priceCacheWrite: model.priceCacheWrite
+        ?? (typeof info.cost?.cache_write === 'number' ? info.cost.cache_write : undefined),
+    };
+  });
+}
+
+/**
+ * omp's models.yml schema requires all four cost fields when cost is present,
+ * so a price is only seeded when both sides are known; missing ones default
+ * to 0. Context/output labels ("128K ctx · 16K out") parse back to tokens.
+ * Cache prices come from the catalog and are kept when known — dropping them
+ * makes every cached turn look free in omp's usage accounting.
+ */
+export function toOmpSeed(model: ProviderModel): {
+  id: string;
+  name?: string;
+  reasoning?: boolean;
+  imageInput?: boolean;
+  contextWindow?: number;
+  maxTokens?: number;
+  cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
+} {
+  const parseTokens = (label: string, suffix: string): number | undefined => {
+    const match = label.match(new RegExp(`(\\d+(?:\\.\\d+)?)([KM])? ${suffix}`));
+    if (!match) return undefined;
+    const value = Number.parseFloat(match[1]);
+    if (!Number.isFinite(value) || value <= 0) return undefined;
+    const multiplier = match[2] === 'M' ? 1_000_000 : 1000;
+    return Math.round(value * multiplier);
+  };
+  const contextWindow = parseTokens(model.contextWindow, 'ctx');
+  const outTokens = parseTokens(model.contextWindow, 'out');
+  // omp rejects the whole file on a non-finite number, so a price has to be a
+  // real finite value before it may be written at all.
+  const price = (value: unknown): number | undefined => (
+    typeof value === 'number' && Number.isFinite(value) ? value : undefined
+  );
+  const priceInput = price(model.priceInput);
+  const priceOutput = price(model.priceOutput);
+  const hasCost = priceInput !== undefined && priceOutput !== undefined;
+  return {
+    id: model.id,
+    ...(model.name && model.name !== model.id ? { name: model.name } : {}),
+    ...(model.hasReasoning ? { reasoning: true } : {}),
+    ...(model.hasVision ? { imageInput: true } : {}),
+    ...(contextWindow ? { contextWindow } : {}),
+    ...(outTokens && outTokens > 0 ? { maxTokens: Math.round(outTokens) } : {}),
+    ...(hasCost ? {
+      cost: {
+        input: priceInput,
+        output: priceOutput,
+        cacheRead: price(model.priceCacheRead) ?? 0,
+        cacheWrite: price(model.priceCacheWrite) ?? 0,
+      },
+    } : {}),
+  };
+}