ompchamber 2.0.2 → 3.0.0

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

@@ -14,7 +14,12 @@
 import { readDisabledProviders } from '@/server/lib/omp/config/disabled-providers';
 import { getModelsConfigPath, readNativeProviders } from '@/server/lib/omp/config/models-config';
 import { runUtilityCommand, type OmpModel } from '@/server/lib/omp/rpc/utility';
-import { isKenariProvider, removeLegacyKenariModels } from '@/shared/lib/models/provider-cleanup';
+import { isKenariProvider, removeLegacyKenariModels } from '@/shared/lib/models/provider/cleanup';
+import {
+  isOmpProviderApi,
+  isProviderAuthMode,
+  isProviderDiscoveryType,
+} from '@/shared/lib/models/provider/dialect';
 import { formatContextWindow } from '@/shared/lib/code/format';
 import type { ProviderItem } from '@/shared/types';
 
@@ -90,10 +95,11 @@ async function loadRpcProviderItems(): Promise<ProviderItem[]> {
         id: `omp-auth-${provider.id}`,
         name: provider.name,
         slug: provider.id,
-        icon: 'plug',
+        icon: provider.id,
         status: (provider.authenticated && !isDisabled ? 'connected' : 'disconnected') as ProviderItem['status'],
         disabled: isDisabled,
         configuredIn: 'omp auth credentials',
+        credentialSource: 'omp-auth' as const,
         models: providerModels.map((model) => ({
           id: model.id,
           name: typeof model.name === 'string' && model.name.length > 0 ? model.name : model.id,
@@ -122,7 +128,7 @@ function disabledProviderItem(slug: string): ProviderItem {
     id: `omp-disabled-${slug}`,
     name: slug,
     slug,
-    icon: 'plug',
+    icon: slug,
     status: 'disconnected',
     disabled: true,
     configuredIn: 'omp disabledProviders',
@@ -135,19 +141,25 @@ function disabledProviderItem(slug: string): ProviderItem {
  * omp's own stores — chamber only surfaces registration info.
  */
 function nativeProviderItem(
-  slug: string,
-  baseUrl: string | undefined,
-  nativeModels: Array<{
-    id: string;
-    name?: string;
-    contextWindow?: number;
-    maxTokens?: number;
-    reasoning?: boolean;
-    imageInput?: boolean;
-  }>,
+  info: {
+    slug: string;
+    baseUrl?: string;
+    api?: string;
+    auth?: string;
+    discovery?: string;
+    models: Array<{
+      id: string;
+      name?: string;
+      contextWindow?: number;
+      maxTokens?: number;
+      reasoning?: boolean;
+      imageInput?: boolean;
+    }>;
+  },
   isDisabled = false,
 ): ProviderItem {
-  const models = nativeModels.map((model) => ({
+  const { slug, baseUrl } = info;
+  const models = info.models.map((model) => ({
     id: model.id,
     name: model.name || model.id,
     contextWindow: model.contextWindow
@@ -163,10 +175,27 @@ function nativeProviderItem(
     id: `omp-native-${slug}`,
     name: slug,
     slug,
-    icon: 'plug',
+    icon: slug,
     status: isDisabled ? 'disconnected' : 'connected',
     disabled: isDisabled,
     configuredIn: baseUrl ? `models.yml · ${baseUrl}` : 'models.yml',
+    credentialSource: 'models.yml' as const,
+    // 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),
   };
 }
@@ -209,6 +238,22 @@ function mergeProviderItems(existing: ProviderItem, incoming: ProviderItem): Pro
     disabled,
     baseUrl: primary.baseUrl || secondary.baseUrl,
     apiKey: primary.apiKey || secondary.apiKey,
+    // A models.yml entry means the endpoint and key live in that file, so the
+    // provider is edited in place; the login-provider half of the merge only
+    // says omp KNOWS the id. Preferring `omp-auth` here is what sent a keyless
+    // local server into an OAuth flow it can never complete.
+    credentialSource: primary.credentialSource === 'models.yml' || secondary.credentialSource === 'models.yml'
+      ? 'models.yml'
+      : primary.credentialSource ?? secondary.credentialSource,
+    // A union, not a winner-takes-all: the two halves see different files
+    // (auth sees login providers, native sees models.yml), and the flag decides
+    // whether the delete button may appear at all.
+    inModelsYml: primary.inModelsYml === true || secondary.inModelsYml === true,
+    // Dialect fields come from whichever side knows them: the auth source
+    // never carries them, the native models.yml source always does.
+    api: primary.api ?? secondary.api,
+    auth: primary.auth ?? secondary.auth,
+    discovery: primary.discovery ?? secondary.discovery,
     configuredIn: primary.apiKey || primary.baseUrl ? primary.configuredIn : secondary.configuredIn,
     models,
   };
@@ -269,12 +314,7 @@ export async function mergeProviders(custom: ProviderItem[]): Promise<{ provider
   const disabled = await readDisabledProviders().catch(() => new Set<string>());
   const authItems = await loadRpcProviderItems();
   const native = await readNativeProviders();
-  const nativeItems = native.map((info) => nativeProviderItem(
-    info.slug,
-    info.baseUrl,
-    info.models,
-    disabled.has(info.slug),
-  ));
+  const nativeItems = native.map((info) => nativeProviderItem(info, disabled.has(info.slug)));
   const disabledItems = [...disabled]
     .filter((slug) => !nativeItems.some((n) => n.slug === slug) && !authItems.some((a) => a.slug === slug))
     .map(disabledProviderItem);
@@ -283,11 +323,22 @@ export async function mergeProviders(custom: ProviderItem[]): Promise<{ provider
     custom,
   );
   const nativeSlugs = new Set(registryItems.map((provider) => provider.slug.toLowerCase()));
+  // `inModelsYml` is stamped from the FILE's own slug set, not from whichever
+  // source supplied the entry. A provider can be described by the auth half or
+  // by a stale overlay row while its models.yml entry is what a delete would
+  // remove — deriving the flag from the supplying half left those entries with
+  // no delete button even though the file held them.
+  const modelsYmlSlugs = new Set(native.map((info) => info.slug.toLowerCase()));
+  const providers = deduplicateProviderItems([
+    ...registryItems,
+    ...custom.filter((p) => !nativeSlugs.has(p.slug.toLowerCase())),
+  ]).map((provider) => (
+    modelsYmlSlugs.has(provider.slug.trim().toLowerCase())
+      ? { ...provider, inModelsYml: true }
+      : provider
+  ));
   return {
-    providers: deduplicateProviderItems([
-      ...registryItems,
-      ...custom.filter((p) => !nativeSlugs.has(p.slug.toLowerCase())),
-    ]),
+    providers,
     modelsConfigPath: await getModelsConfigPath(),
   };
 }

package/src/server/lib/omp/config/models-config.ts

@@ -36,6 +36,12 @@ export interface NativeProviderInfo {
   slug: string;
   /** Base URL of the provider API, when configured. */
   baseUrl?: string;
+  /** Wire dialect from the entry's `api`, when it declares one. */
+  api?: string;
+  /** Auth mode from the entry's `auth`; `none` means keyless. */
+  auth?: string;
+  /** Discovery type from the entry's `discovery`, when omp lists its models. */
+  discovery?: string;
   /** Model ids registered under this provider in models.yml. */
   modelIds: string[];
   models: NativeModelInfo[];
@@ -69,6 +75,11 @@ export async function readNativeProviders(): Promise<NativeProviderInfo[]> {
       const info: NativeProviderInfo = { slug, modelIds: [], models: [] };
       if (isRecord(value)) {
         if (typeof value.baseUrl === 'string') info.baseUrl = value.baseUrl;
+        if (typeof value.api === 'string') info.api = value.api;
+        if (typeof value.auth === 'string') info.auth = value.auth;
+        if (isRecord(value.discovery) && typeof value.discovery.type === 'string') {
+          info.discovery = value.discovery.type;
+        }
         if (Array.isArray(value.models)) {
           info.models = value.models.flatMap((model) => {
             if (!isRecord(model) || typeof model.id !== 'string') return [];

package/src/server/lib/omp/config/models-validation.test.ts

@@ -0,0 +1,137 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Validation of the provider shapes the settings UI can now write.
+ *
+ * omp's failure mode is what makes these worth locking: one schema violation
+ * anywhere in `models.yml` makes it disable EVERY custom provider at once, so a
+ * dialect or auth value the UI let through takes the whole registry down. Each
+ * case below was verified against omp 18.3.0 by loading the document.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { validateModelsDocument } from '@/server/lib/omp/config/models-validation';
+
+describe('validateModelsDocument — dialect fields', () => {
+  test('accepts every api omp ships', () => {
+    const apis = [
+      'openai-completions', 'openai-responses', 'openai-codex-responses',
+      'azure-openai-responses', 'anthropic-messages', 'bedrock-converse-stream',
+      'google-generative-ai', 'google-gemini-cli', 'google-vertex',
+      'openrouter-decisions', 'typesafe',
+    ];
+    for (const api of apis) {
+      expect(validateModelsDocument({ providers: { p: { api, baseUrl: 'https://x/v1', apiKey: 'k' } } }))
+        .toEqual([]);
+    }
+  });
+
+  test('rejects an api omp does not know', () => {
+    const errors = validateModelsDocument({
+      providers: { p: { api: 'openai-completions-v2', baseUrl: 'https://x/v1', apiKey: 'k' } },
+    });
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('unknown "api" value');
+  });
+
+  test('accepts the three auth modes and rejects anything else', () => {
+    for (const auth of ['apiKey', 'none', 'oauth']) {
+      expect(validateModelsDocument({ providers: { p: { baseUrl: 'https://x/v1', auth } } })).toEqual([]);
+    }
+    const errors = validateModelsDocument({ providers: { p: { baseUrl: 'https://x/v1', auth: 'bearer' } } });
+    expect(errors.some((error) => error.includes('unknown "auth" value'))).toBe(true);
+  });
+
+  test('a keyless provider needs no apiKey even with models', () => {
+    // This is the shape a local server is registered with; demanding a key here
+    // is what made every keyless provider look unconfigured.
+    expect(validateModelsDocument({
+      providers: { local: { baseUrl: 'http://127.0.0.1:11434/v1', api: 'openai-responses', auth: 'none', models: [{ id: 'm' }] } },
+    })).toEqual([]);
+  });
+
+  test('a models-carrying provider without auth still requires a key', () => {
+    const errors = validateModelsDocument({
+      providers: { p: { baseUrl: 'https://x/v1', api: 'openai-completions', models: [{ id: 'm' }] } },
+    });
+    expect(errors.some((error) => error.includes('"apiKey" is required'))).toBe(true);
+  });
+});
+
+describe('validateModelsDocument — discovery', () => {
+  test('accepts a discovery shell with no models at all', () => {
+    // A discovery provider legitimately carries an empty model list; omp lists
+    // the models itself.
+    expect(validateModelsDocument({
+      providers: { disc: { baseUrl: 'http://127.0.0.1:11434', api: 'openai-responses', discovery: { type: 'ollama' } } },
+    })).toEqual([]);
+  });
+
+  test('accepts every discovery type omp ships', () => {
+    for (const type of ['ollama', 'llama.cpp', 'lm-studio', 'openai-models-list', 'litellm', 'apple-foundation-models']) {
+      expect(validateModelsDocument({
+        providers: { p: { baseUrl: 'https://x/v1', api: 'openai-completions', discovery: { type } } },
+      })).toEqual([]);
+    }
+    expect(validateModelsDocument({
+      providers: { p: { baseUrl: 'https://x/v1', api: 'openai-completions', discovery: { type: 'proxy' } } },
+    })).toEqual([]);
+  });
+
+  test('rejects an unknown discovery type', () => {
+    const errors = validateModelsDocument({
+      providers: { p: { baseUrl: 'https://x/v1', api: 'openai-completions', discovery: { type: 'vllm' } } },
+    });
+    expect(errors.some((error) => error.includes('unknown discovery type'))).toBe(true);
+  });
+
+  test('discovery without a provider api is refused, except for proxy', () => {
+    const withoutApi = validateModelsDocument({
+      providers: { p: { baseUrl: 'https://x/v1', discovery: { type: 'openai-models-list' } } },
+    });
+    expect(withoutApi.some((error) => error.includes('"api" is required when discovery'))).toBe(true);
+
+    const proxy = validateModelsDocument({
+      providers: { p: { baseUrl: 'https://x/v1', discovery: { type: 'proxy' } } },
+    });
+    expect(proxy).toEqual([]);
+  });
+
+  test('injectV1 is only allowed on openai-models-list', () => {
+    const errors = validateModelsDocument({
+      providers: { p: { baseUrl: 'https://x/v1', api: 'openai-completions', discovery: { type: 'ollama', injectV1: false } } },
+    });
+    expect(errors.some((error) => error.includes('injectV1 only on'))).toBe(true);
+  });
+});
+
+describe('validateModelsDocument — override-only providers', () => {
+  test('a bare endpoint override for a bundled provider is valid', () => {
+    // The documented way to point a bundled provider at a proxy: no models,
+    // just an endpoint. omp then keeps serving its own model list.
+    expect(validateModelsDocument({ providers: { anthropic: { baseUrl: 'https://proxy.example.com' } } }))
+      .toEqual([]);
+  });
+
+  test('a provider with no configuration at all is still refused', () => {
+    const errors = validateModelsDocument({ providers: { empty: {} } });
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('must specify');
+  });
+
+  test('an empty apiKey is refused — omp rejects it', () => {
+    const errors = validateModelsDocument({ providers: { p: { baseUrl: 'https://x/v1', apiKey: '' } } });
+    expect(errors.some((error) => error.includes('"apiKey" must be a non-empty string'))).toBe(true);
+  });
+
+  test('a map-form models entry is refused as a file-breaking shape', () => {
+    const errors = validateModelsDocument({
+      providers: { p: { baseUrl: 'https://x/v1', apiKey: 'k', models: { a: {} } } },
+    });
+    expect(errors).toEqual(['Provider p: "models" must be an array']);
+  });
+});

package/src/server/lib/omp/config/models-validation.ts

@@ -38,6 +38,70 @@ const API_VALUES = new Set([
 /** Auth modes that make an `apiKey` optional (omp: `ProviderAuthSchema`). */
 const KEYLESS_AUTH = new Set(['none', 'oauth']);
 
+/** Every value omp's `ProviderAuthSchema` accepts. */
+const AUTH_VALUES = new Set(['apiKey', 'none', 'oauth']);
+
+/** Every value omp's `ProviderDiscoverySchema.type` accepts. */
+const DISCOVERY_TYPES = new Set([
+  'ollama',
+  'llama.cpp',
+  'lm-studio',
+  'openai-models-list',
+  'proxy',
+  'litellm',
+  'apple-foundation-models',
+]);
+
+/** Every value omp's `ThinkingControlModeSchema` accepts. */
+const THINKING_MODES = new Set([
+  'effort',
+  'budget',
+  'google-level',
+  'anthropic-adaptive',
+  'anthropic-budget-effort',
+]);
+
+/** Every value omp's `EffortSchema` accepts. `off` is NOT one of them. */
+const EFFORT_VALUES = new Set(['minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+
+/**
+ * Every reason a `thinking` block would fail omp's `ModelThinkingSchema`.
+ *
+ * The block is written by the chamber whenever a user ticks an effort ladder,
+ * and omp's failure mode is unforgiving: a missing `mode` or an effort outside
+ * the vocabulary makes it disable EVERY custom provider in the file.
+ */
+function thinkingErrors(label: string, thinking: unknown): string[] {
+  const errors: string[] = [];
+  if (!isRecord(thinking)) return [`${label}: "thinking" must be a mapping`];
+  if (thinking.mode === undefined) {
+    errors.push(`${label}: "thinking.mode" is required`);
+  } else if (!THINKING_MODES.has(String(thinking.mode))) {
+    errors.push(`${label}: unknown thinking mode ${JSON.stringify(thinking.mode)}`);
+  }
+  const efforts = thinking.efforts;
+  if (efforts !== undefined) {
+    if (!Array.isArray(efforts)) {
+      errors.push(`${label}: "thinking.efforts" must be an array`);
+    } else {
+      for (const effort of efforts) {
+        if (!EFFORT_VALUES.has(String(effort))) {
+          errors.push(`${label}: unknown thinking effort ${JSON.stringify(effort)}`);
+        }
+      }
+    }
+  }
+  // `efforts` is what makes the ladder meaningful; omp requires one of the
+  // three vocabularies, so a block carrying none of them is rejected on load.
+  const hasLadder = Array.isArray(efforts)
+    || Array.isArray(thinking.levels)
+    || (thinking.minLevel !== undefined && thinking.maxLevel !== undefined);
+  if (!hasLadder) {
+    errors.push(`${label}: "thinking" needs "efforts" (or legacy "levels"/"minLevel"+"maxLevel")`);
+  }
+  return errors;
+}
+
 /** A finite number, which is what omp's `"number"` type means — `NaN` and `Infinity` are rejected. */
 function isFiniteNumber(value: unknown): value is number {
   return typeof value === 'number' && Number.isFinite(value);
@@ -75,6 +139,28 @@ export function validateModelsDocument(doc: Record<string, unknown> | null | und
     if (typeof value.apiKey === 'string' && value.apiKey.length === 0) {
       errors.push(`Provider ${slug}: "apiKey" must be a non-empty string`);
     }
+    if (value.auth !== undefined && !AUTH_VALUES.has(String(value.auth))) {
+      errors.push(`Provider ${slug}: unknown "auth" value ${JSON.stringify(value.auth)}`);
+    }
+    const discovery = value.discovery;
+    if (discovery !== undefined) {
+      if (!isRecord(discovery)) {
+        errors.push(`Provider ${slug}: "discovery" must be a mapping`);
+      } else {
+        const type = String(discovery.type);
+        if (!DISCOVERY_TYPES.has(type)) {
+          errors.push(`Provider ${slug}: unknown discovery type ${JSON.stringify(discovery.type)}`);
+        }
+        // omp needs a dialect to interpret the discovered entries; a proxy
+        // reports one per model instead, so it is the documented exception.
+        if (providerApi === undefined && type !== 'proxy') {
+          errors.push(`Provider ${slug}: "api" is required when discovery is enabled at provider level.`);
+        }
+        if (discovery.injectV1 !== undefined && type !== 'openai-models-list') {
+          errors.push(`Provider ${slug}: injectV1 only on openai-models-list discovery`);
+        }
+      }
+    }
 
     const models = value.models;
     if (models !== undefined && !Array.isArray(models)) {
@@ -94,8 +180,21 @@ export function validateModelsDocument(doc: Record<string, unknown> | null | und
       if (typeof value.apiKey !== 'string' && !KEYLESS_AUTH.has(auth)) {
         errors.push(`Provider ${slug}: "apiKey" is required when defining custom models unless auth is "none" or "oauth".`);
       }
-    } else if (!value.baseUrl && !value.apiKey && !value.discovery && value.auth !== 'none' && !value.modelOverrides) {
-      errors.push(`Provider ${slug}: must specify "baseUrl", "apiKey", "auth: none", "discovery", "modelOverrides", or "models"`);
+    } else if (
+      !value.baseUrl
+      && !value.apiKey
+      && !value.headers
+      && !value.compat
+      && !value.discovery
+      && !value.remoteCompaction
+      && !value.disableStrictTools
+      && !value.modelOverrides
+      && value.auth !== 'none'
+    ) {
+      errors.push(
+        `Provider ${slug}: must specify "baseUrl", "apiKey", "auth: none", "headers", "compat", `
+        + '"discovery", "remoteCompaction", "modelOverrides", or "models"',
+      );
     }
 
     for (const [index, model] of modelList.entries()) {
@@ -111,6 +210,9 @@ export function validateModelsDocument(doc: Record<string, unknown> | null | und
       if (model.api !== undefined && !API_VALUES.has(String(model.api))) {
         errors.push(`Provider ${slug}, model ${id}: unknown "api" value ${JSON.stringify(model.api)}`);
       }
+      if (model.thinking !== undefined) {
+        errors.push(...thinkingErrors(`Provider ${slug}, model ${id}`, model.thinking));
+      }
       if (providerApi === undefined && model.api === undefined) {
         errors.push(`Provider ${slug}, model ${id}: no "api" specified. Set at provider or model level.`);
       }
@@ -153,6 +255,13 @@ export function sanitizeModelEntry(model: Record<string, unknown>): Record<strin
       delete next.cost;
     }
   }
+  // An unusable ladder is dropped rather than written: a `thinking` block with
+  // no mode, or with an effort omp does not know, takes EVERY custom provider
+  // down with it. Dropping it leaves the model with omp's default ladder, which
+  // is the honest repair — the model still runs.
+  if (next.thinking !== undefined && thinkingErrors('model', next.thinking).length > 0) {
+    delete next.thinking;
+  }
   if (!isOptionalPositive(next.contextWindow)) delete next.contextWindow;
   if (!isOptionalPositive(next.maxTokens)) delete next.maxTokens;
   return next;

package/src/server/lib/omp/config/provider-seeds.test.ts

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The seed a hand-entered model becomes.
+ *
+ * The Add Model dialog is the only writer whose values come from a person
+ * rather than a provider listing, so it is the only one that can carry a
+ * mistake into models.yml. omp's failure mode is what makes that expensive: one
+ * bad entry makes it disable EVERY custom provider in the file, so a
+ * non-positive limit or a half-filled price has to be dropped here rather than
+ * validated after the fact.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { manualModelSeed, toModelEntry } from '@/server/lib/omp/config/provider-seeds';
+import { validateModelsDocument, sanitizeModelEntry } from '@/server/lib/omp/config/models-validation';
+
+describe('manualModelSeed', () => {
+  test('keeps the metadata the user entered', () => {
+    expect(manualModelSeed({
+      id: 'my-model',
+      name: 'My Model',
+      contextWindow: 200000,
+      maxTokens: 8192,
+      reasoning: true,
+      imageInput: true,
+      costInput: 0.5,
+      costOutput: 1.5,
+      costCacheRead: 0.05,
+      costCacheWrite: 0.1,
+    })).toEqual({
+      id: 'my-model',
+      name: 'My Model',
+      reasoning: true,
+      imageInput: true,
+      contextWindow: 200000,
+      maxTokens: 8192,
+      cost: { input: 0.5, output: 1.5, cacheRead: 0.05, cacheWrite: 0.1 },
+    });
+  });
+
+  test('an id alone is a valid entry', () => {
+    // The common case is "add this id I know exists" — every other field is
+    // metadata omp can work without, so requiring them would block it.
+    expect(manualModelSeed({ id: '  bare-id  ' })).toEqual({ id: 'bare-id' });
+  });
+
+  test('drops non-positive limits instead of writing them', () => {
+    // omp rejects contextWindow/maxTokens <= 0 outright, which takes every
+    // custom provider down with it.
+    const seed = manualModelSeed({ id: 'm', contextWindow: 0, maxTokens: -1 });
+    expect(seed.contextWindow).toBeUndefined();
+    expect(seed.maxTokens).toBeUndefined();
+  });
+
+  test('rounds fractional token counts', () => {
+    expect(manualModelSeed({ id: 'm', contextWindow: 128000.7 }).contextWindow).toBe(128001);
+  });
+
+  test('writes a price only when both sides are known', () => {
+    // omp's schema requires all four cost fields together; half a price would
+    // be a schema violation, not a partial price.
+    expect(manualModelSeed({ id: 'm', costInput: 1 }).cost).toBeUndefined();
+    expect(manualModelSeed({ id: 'm', costOutput: 1 }).cost).toBeUndefined();
+    expect(manualModelSeed({ id: 'm', costInput: 1, costOutput: 2 }).cost)
+      .toEqual({ input: 1, output: 2, cacheRead: 0, cacheWrite: 0 });
+  });
+
+  test('a seed the user entered produces a document omp accepts', () => {
+    const seed = manualModelSeed({
+      id: 'my-model',
+      name: 'My Model',
+      contextWindow: 200000,
+      maxTokens: 8192,
+      reasoning: true,
+      costInput: 0,
+      costOutput: 0,
+    });
+    const entry = sanitizeModelEntry({
+      id: seed.id,
+      ...(seed.name ? { name: seed.name } : {}),
+      ...(seed.reasoning !== undefined ? { reasoning: seed.reasoning } : {}),
+      input: ['text'],
+      ...(seed.contextWindow ? { contextWindow: seed.contextWindow } : {}),
+      ...(seed.maxTokens ? { maxTokens: seed.maxTokens } : {}),
+      ...(seed.cost ? { cost: seed.cost } : {}),
+    });
+    expect(validateModelsDocument({
+      providers: {
+        p: { baseUrl: 'https://x/v1', apiKey: 'k', api: 'openai-completions', models: [entry] },
+      },
+    })).toEqual([]);
+  });
+});
+
+describe('manualModelSeed — reasoning ladder', () => {
+  test('declares the ladder the user ticked, in omp order', () => {
+    expect(manualModelSeed({
+      id: 'm',
+      reasoning: true,
+      efforts: ['high', 'low'],
+    }).efforts).toEqual(['high', 'low']);
+  });
+
+  test('an empty ladder is not declared', () => {
+    // omp already assumes its own default ladder for a reasoning model, so an
+    // empty list would write a block that changes nothing.
+    expect(manualModelSeed({ id: 'm', reasoning: true, efforts: [] }).efforts).toBeUndefined();
+  });
+
+  test('a ladder without reasoning is dropped', () => {
+    // A capability the user did not enable must not be declared; omp would
+    // advertise levels for a model it is told cannot reason.
+    expect(manualModelSeed({ id: 'm', efforts: ['high'] }).efforts).toBeUndefined();
+  });
+
+  test('a repeated level is collapsed', () => {
+    expect(manualModelSeed({ id: 'm', reasoning: true, efforts: ['low', 'low'] }).efforts).toEqual(['low']);
+  });
+
+  test('the written entry carries thinking.mode and omp accepts it', () => {
+    const seed = manualModelSeed({ id: 'm', reasoning: true, efforts: ['low', 'high'] });
+    const entry = toModelEntry(seed);
+    expect(entry.thinking).toEqual({ mode: 'effort', efforts: ['low', 'high'] });
+    expect(validateModelsDocument({
+      providers: { p: { baseUrl: 'https://x/v1', apiKey: 'k', api: 'openai-completions', models: [entry] } },
+    })).toEqual([]);
+  });
+
+  test('a model without a ladder writes no thinking block at all', () => {
+    expect(toModelEntry(manualModelSeed({ id: 'm', reasoning: true })).thinking).toBeUndefined();
+  });
+});
+
+describe('validateModelsDocument — thinking', () => {
+  test('refuses a ladder omp does not know', () => {
+    const errors = validateModelsDocument({
+      providers: {
+        p: { baseUrl: 'https://x/v1', apiKey: 'k', api: 'openai-completions',
+          models: [{ id: 'm', reasoning: true, thinking: { mode: 'effort', efforts: ['off'] } }] },
+      },
+    });
+    expect(errors.some((error) => error.includes('unknown thinking effort'))).toBe(true);
+  });
+
+  test('refuses a thinking block with no mode', () => {
+    // omp's own error for this is a schema failure that disables every custom
+    // provider, so it must never reach the file.
+    const errors = validateModelsDocument({
+      providers: {
+        p: { baseUrl: 'https://x/v1', apiKey: 'k', api: 'openai-completions',
+          models: [{ id: 'm', reasoning: true, thinking: { efforts: ['low'] } }] },
+      },
+    });
+    expect(errors.some((error) => error.includes('"thinking.mode" is required'))).toBe(true);
+  });
+
+  test('sanitize drops an unusable thinking block rather than the model', () => {
+    const entry = sanitizeModelEntry({ id: 'm', reasoning: true, thinking: { mode: 'nope', efforts: ['low'] } });
+    expect(entry.thinking).toBeUndefined();
+    expect(entry.id).toBe('m');
+  });
+});