ompchamber 2.0.2 → 3.0.0

package/src/shared/lib/fs/diff-parser.test.ts

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The whitespace toggle's contract. Trimming the displayed text left a
+ * whitespace-only rewrite painted red/green and counted in `+n/-n`, so the
+ * toggle changed the glyphs and nothing else — these cases pin the behavior a
+ * reader actually expects from it.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { parseUnifiedDiff } from '@/shared/lib/fs/diff-parser';
+
+const WHITESPACE_ONLY = [
+  'diff --git a/ws.ts b/ws.ts',
+  'index 46378b4..c824424 100644',
+  '--- a/ws.ts',
+  '+++ b/ws.ts',
+  '@@ -1,3 +1,3 @@',
+  ' function ws() {',
+  '-  return 1;',
+  '+    return 1;',
+  ' }',
+  '',
+].join('\n');
+
+const REAL_CHANGE = [
+  'diff --git a/main.ts b/main.ts',
+  '--- a/main.ts',
+  '+++ b/main.ts',
+  '@@ -1,2 +1,2 @@',
+  ' export const a = 1;',
+  '-export function f() { return a; }',
+  '+export function f() { return a + 1; }',
+  '',
+].join('\n');
+
+const MIXED = [
+  'diff --git a/mixed.ts b/mixed.ts',
+  '--- a/mixed.ts',
+  '+++ b/mixed.ts',
+  '@@ -1,3 +1,3 @@',
+  '-  const a = 1;',
+  '+    const a = 1;',
+  '-  const b = 2;',
+  '+  const b = 3;',
+  '',
+].join('\n');
+
+describe('parseUnifiedDiff', () => {
+  test('counts and marks a whitespace-only rewrite by default', () => {
+    const { lines, additions, deletions } = parseUnifiedDiff(WHITESPACE_ONLY);
+
+    expect(additions).toBe(1);
+    expect(deletions).toBe(1);
+    expect(lines.filter((l) => l.type === 'add')).toHaveLength(1);
+    expect(lines.filter((l) => l.type === 'del')).toHaveLength(1);
+  });
+
+  test('folds a whitespace-only rewrite into context when ignoring whitespace', () => {
+    const { lines, splitRows, additions, deletions } = parseUnifiedDiff(WHITESPACE_ONLY, true);
+
+    // The counts the toolbar renders must match what is on screen.
+    expect(additions).toBe(0);
+    expect(deletions).toBe(0);
+    expect(lines.some((l) => l.type === 'add' || l.type === 'del')).toBe(false);
+
+    const folded = lines.find((l) => l.type === 'context' && l.oldLineNumber === 2);
+    expect(folded?.newLineNumber).toBe(2);
+    expect(folded?.text).toBe('    return 1;');
+
+    // Split view reads the same decision — it is built by the same flush.
+    const row = splitRows.find((r) => r.left?.lineNumber === 2);
+    expect(row?.left?.type).toBe('context');
+    expect(row?.right?.type).toBe('context');
+    expect(row?.left?.text).toBe('  return 1;');
+    expect(row?.right?.text).toBe('    return 1;');
+  });
+
+  test('keeps a real change when ignoring whitespace', () => {
+    const { lines, additions, deletions } = parseUnifiedDiff(REAL_CHANGE, true);
+
+    expect(additions).toBe(1);
+    expect(deletions).toBe(1);
+    expect(lines.find((l) => l.type === 'del')?.text).toBe('export function f() { return a; }');
+    expect(lines.find((l) => l.type === 'add')?.text).toBe('export function f() { return a + 1; }');
+  });
+
+  test('folds only the whitespace pair of a mixed hunk', () => {
+    const { lines, additions, deletions } = parseUnifiedDiff(MIXED, true);
+
+    // Line 1 differs by indentation only; line 2 is a genuine edit.
+    expect(additions).toBe(1);
+    expect(deletions).toBe(1);
+    expect(lines.filter((l) => l.type === 'del').map((l) => l.text)).toEqual(['  const b = 2;']);
+    expect(lines.filter((l) => l.type === 'add').map((l) => l.text)).toEqual(['  const b = 3;']);
+  });
+
+  test('emits unified lines in diff order (deletions before additions)', () => {
+    const { lines } = parseUnifiedDiff(REAL_CHANGE);
+    const kinds = lines.map((l) => l.type);
+
+    // A git diff ends with a newline, which `split` turns into one trailing
+    // empty context line — pre-existing, and the same row the view has always
+    // drawn under the last change.
+    expect(kinds.slice(0, 4)).toEqual(['meta', 'context', 'del', 'add']);
+  });
+
+  test('returns empty results for an empty diff', () => {
+    expect(parseUnifiedDiff('', true)).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
+    expect(parseUnifiedDiff('   \n', false)).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
+  });
+});

package/src/shared/lib/fs/diff-parser.ts

@@ -6,20 +6,31 @@ export interface DiffLine {
 }
 
 export interface SplitDiffRow {
-  left?: {
-    type: 'del' | 'context';
-    text: string;
-    lineNumber: number;
-  };
-  right?: {
-    type: 'add' | 'context';
-    text: string;
-    lineNumber: number;
-  };
+  left?: { type: 'del' | 'context'; text: string; lineNumber: number };
+  right?: { type: 'add' | 'context'; text: string; lineNumber: number };
   isMeta?: boolean;
   metaText?: string;
 }
 
+/** A buffered `-`/`+` line, before it is decided whether it is a real change. */
+interface PendingChange {
+  text: string;
+  lineNumber: number;
+}
+
+/**
+ * Parse a unified diff into the flat line list (Unified view) and the paired
+ * row list (Split view), plus the addition/deletion counts the toolbar shows.
+ *
+ * Both outputs are produced by the same flush, so a decision made here cannot
+ * land in one view and not the other.
+ *
+ * With `ignoreWhitespace`, a `-`/`+` pair whose text differs only in whitespace
+ * is folded back into context: the change is still in the file, but the reader
+ * asked not to be shown formatting noise. Merely trimming the displayed text —
+ * which is what this used to do — left the row painted red/green and counted in
+ * `+n/-n`, so the toggle changed the glyphs and nothing else.
+ */
 export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = false): {
   lines: DiffLine[];
   splitRows: SplitDiffRow[];
@@ -44,16 +55,60 @@ export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = fa
   let oldCounter = 1;
   let newCounter = 1;
 
-  // Buffer for pairing consecutive deletions and additions in split view
-  let delBuffer: { text: string; lineNumber: number }[] = [];
-  let addBuffer: { text: string; lineNumber: number }[] = [];
+  // Consecutive deletions and additions, paired up in split view.
+  let delBuffer: PendingChange[] = [];
+  let addBuffer: PendingChange[] = [];
 
   const flushBuffers = () => {
     const maxLen = Math.max(delBuffer.length, addBuffer.length);
+    // A whitespace-only rewrite is decided per pair, but the flat line list
+    // keeps unified-diff order (every `-` of the group, then every `+`), which
+    // is what the original loop produced as it walked the raw diff.
+    const folded = new Array<boolean>(maxLen).fill(false);
+    if (ignoreWhitespace) {
+      for (let i = 0; i < maxLen; i++) {
+        const del = delBuffer[i];
+        const add = addBuffer[i];
+        folded[i] = Boolean(del && add && del.text.trim() === add.text.trim());
+      }
+    }
+
+    for (let i = 0; i < delBuffer.length; i++) {
+      const del = delBuffer[i];
+      const add = addBuffer[i];
+      if (folded[i] && add) {
+        // Show it as unchanged on both sides: the change is still in the file,
+        // the reader asked not to be shown formatting noise.
+        lines.push({
+          type: 'context',
+          // The new form, so the row reads as the file's current state.
+          text: add.text,
+          oldLineNumber: del.lineNumber,
+          newLineNumber: add.lineNumber,
+        });
+        continue;
+      }
+      lines.push({ type: 'del', text: del.text, oldLineNumber: del.lineNumber });
+    }
+    for (let i = 0; i < addBuffer.length; i++) {
+      const add = addBuffer[i];
+      if (folded[i]) continue;
+      lines.push({ type: 'add', text: add.text, newLineNumber: add.lineNumber });
+    }
+
     for (let i = 0; i < maxLen; i++) {
+      const del = delBuffer[i];
+      const add = addBuffer[i];
+      if (folded[i] && del && add) {
+        splitRows.push({
+          left: { type: 'context', text: del.text, lineNumber: del.lineNumber },
+          right: { type: 'context', text: add.text, lineNumber: add.lineNumber },
+        });
+        continue;
+      }
       splitRows.push({
-        left: delBuffer[i] ? { type: 'del', text: delBuffer[i].text, lineNumber: delBuffer[i].lineNumber } : undefined,
-        right: addBuffer[i] ? { type: 'add', text: addBuffer[i].text, lineNumber: addBuffer[i].lineNumber } : undefined,
+        left: del ? { type: 'del', text: del.text, lineNumber: del.lineNumber } : undefined,
+        right: add ? { type: 'add', text: add.text, lineNumber: add.lineNumber } : undefined,
       });
     }
     delBuffer = [];
@@ -90,39 +145,26 @@ export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = fa
 
     if (rawLine.startsWith('+')) {
       const text = rawLine.slice(1);
-      const normalizedText = ignoreWhitespace ? text.trim() : text;
       additions++;
-      lines.push({
-        type: 'add',
-        text: normalizedText,
-        newLineNumber: newCounter,
-      });
-      addBuffer.push({ text: normalizedText, lineNumber: newCounter });
+      addBuffer.push({ text, lineNumber: newCounter });
       newCounter++;
     } else if (rawLine.startsWith('-')) {
       const text = rawLine.slice(1);
-      const normalizedText = ignoreWhitespace ? text.trim() : text;
       deletions++;
-      lines.push({
-        type: 'del',
-        text: normalizedText,
-        oldLineNumber: oldCounter,
-      });
-      delBuffer.push({ text: normalizedText, lineNumber: oldCounter });
+      delBuffer.push({ text, lineNumber: oldCounter });
       oldCounter++;
     } else {
       flushBuffers();
       const text = rawLine.startsWith(' ') ? rawLine.slice(1) : rawLine;
-      const normalizedText = ignoreWhitespace ? text.trim() : text;
       lines.push({
         type: 'context',
-        text: normalizedText,
+        text,
         oldLineNumber: oldCounter,
         newLineNumber: newCounter,
       });
       splitRows.push({
-        left: { type: 'context', text: normalizedText, lineNumber: oldCounter },
-        right: { type: 'context', text: normalizedText, lineNumber: newCounter },
+        left: { type: 'context', text, lineNumber: oldCounter },
+        right: { type: 'context', text, lineNumber: newCounter },
       });
       oldCounter++;
       newCounter++;
@@ -131,5 +173,16 @@ export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = fa
 
   flushBuffers();
 
+  if (ignoreWhitespace) {
+    // The counts were tallied before the pairs could be folded, so re-derive
+    // them from what is actually shown.
+    additions = 0;
+    deletions = 0;
+    for (const line of lines) {
+      if (line.type === 'add') additions++;
+      else if (line.type === 'del') deletions++;
+    }
+  }
+
   return { lines, splitRows, additions, deletions };
 }

package/src/shared/lib/models/{provider-connection.ts → provider/connection.ts}

@@ -39,3 +39,40 @@ export function saveProviderOverlay(providers: ProviderItem[]): Promise<Provider
 export function setProviderEnabled(slug: string, enabled: boolean): Promise<ProviderItem[] | null> {
   return postProviders(enabled ? { enableProvider: slug } : { disableProvider: slug });
 }
+
+export interface ProviderDeleteResult {
+  ok: boolean;
+  providers?: ProviderItem[];
+  /** True when a `models.yml` entry was actually removed. */
+  removedFromOmp?: boolean;
+  /** How many model entries went with it. */
+  modelsRemoved?: number;
+  /** The overlay row went but the file cleanup failed — surfaced, not swallowed. */
+  warning?: string;
+  error?: string;
+}
+
+/**
+ * Delete a provider: its chamber overlay row AND its `models.yml` entry.
+ *
+ * The provider is identified by the id the registry served, because a provider
+ * that exists only in models.yml has no overlay row to match on — the server
+ * resolves the id against the merged registry to find the slug to unregister.
+ */
+export async function deleteProvider(id: string): Promise<ProviderDeleteResult> {
+  try {
+    const response = await fetch(`${PROVIDERS_ENDPOINT}?id=${encodeURIComponent(id)}`, { method: 'DELETE' });
+    const data = await response.json() as ProviderDeleteResult;
+    if (!response.ok) {
+      return { ok: false, error: data?.error || `Delete failed (HTTP ${response.status})` };
+    }
+    // The provider — and every model it served — leaves the chat picker.
+    notifyModelsUpdated();
+    return { ...data, ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : 'Network error while deleting the provider',
+    };
+  }
+}

package/src/shared/lib/models/provider/dialect.ts

@@ -0,0 +1,179 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The provider DIALECT — which wire API a custom provider speaks, how it
+ * authenticates, and how its model list is obtained. All three are omp
+ * `models.yml` provider fields, and all three change what a provider can do:
+ *
+ * - `api` selects the request/response shape. A gateway that speaks
+ *   `anthropic-messages` is not reachable through the OpenAI-compatible path,
+ *   and omp rejects an unknown `api` by disabling EVERY custom provider in the
+ *   file — so the value must come from omp's own `ApiSchema`.
+ * - `auth: none` is what makes a local server keyless; without it omp demands
+ *   an `apiKey` and a keyless provider is rejected as unconfigured.
+ * - `discovery` lets OMP list the models live from the endpoint instead of the
+ *   chamber writing a snapshot of ids into `models.yml`.
+ *
+ * Pure data + pure functions, shared by the server (which validates and writes
+ * the file) and the client (which offers the choices), so the two cannot
+ * disagree about what omp accepts.
+ */
+
+import type { OmpProviderApi, ProviderAuthMode, ProviderDiscoveryType, ProviderModelSource } from '@/shared/types/settings/provider';
+
+/** Every `api` omp accepts, in omp's own `ApiSchema` order. */
+export const PROVIDER_APIS: readonly OmpProviderApi[] = [
+  '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',
+];
+
+/** One-line explanation of what each dialect is, for the picker. */
+export const PROVIDER_API_LABELS: Readonly<Record<OmpProviderApi, string>> = {
+  'openai-completions': 'OpenAI Chat Completions — the default for gateways and local servers',
+  'openai-responses': 'OpenAI Responses API — newer OpenAI-shaped endpoints',
+  'openai-codex-responses': 'OpenAI Codex Responses — Codex-style endpoints',
+  'azure-openai-responses': 'Azure OpenAI Responses — api-key header, api-version query',
+  'anthropic-messages': 'Anthropic Messages — Claude-shaped proxies (x-api-key)',
+  'bedrock-converse-stream': 'Amazon Bedrock Converse — AWS credential chain',
+  'google-generative-ai': 'Google Generative AI — Gemini API (x-goog-api-key)',
+  'google-gemini-cli': 'Google Gemini CLI — OAuth-backed Gemini route',
+  'google-vertex': 'Google Vertex AI — service-account / ADC route',
+  'openrouter-decisions': 'OpenRouter decisions — judge role only',
+  typesafe: 'Typesafe System One — judge role only',
+};
+
+/**
+ * omp's `EffortSchema` — the reasoning ladder, lowest first, in omp's own
+ * `EFFORT_ORDER`.
+ *
+ * `off` is deliberately absent: omp rejects it inside `thinking.efforts`
+ * ("must be minimal, low, medium, high, xhigh or max"), because turning thinking
+ * off is a per-turn choice rather than a declared capability. A model that
+ * declares no effort ladder at all still gets omp's default one.
+ */
+export const PROVIDER_THINKING_EFFORTS = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
+
+export type ProviderThinkingEffort = (typeof PROVIDER_THINKING_EFFORTS)[number];
+
+/** True when `value` is an effort omp's `EffortSchema` accepts. */
+export function isProviderThinkingEffort(value: unknown): value is ProviderThinkingEffort {
+  return typeof value === 'string' && (PROVIDER_THINKING_EFFORTS as readonly string[]).includes(value);
+}
+
+/** Auth modes omp accepts, with the meaning the picker shows. */
+export const PROVIDER_AUTH_MODES: ReadonlyArray<{
+  value: ProviderAuthMode;
+  label: string;
+  hint: string;
+}> = [
+  { value: 'apiKey', label: 'API key', hint: 'omp requires a key for this provider' },
+  { value: 'none', label: 'No auth (keyless)', hint: 'Local server that needs no credential' },
+  { value: 'oauth', label: 'OAuth', hint: 'Claude-Code-style proxy expecting the cloaked request shape' },
+];
+
+/** Discovery types omp can drive itself, with what each one probes. */
+export const PROVIDER_DISCOVERY_TYPES: ReadonlyArray<{
+  value: ProviderDiscoveryType;
+  label: string;
+  hint: string;
+}> = [
+  { value: 'openai-models-list', label: 'OpenAI /v1/models', hint: 'Any OpenAI-compatible endpoint' },
+  { value: 'ollama', label: 'Ollama', hint: 'Native Ollama /api/tags + /api/show' },
+  { value: 'llama.cpp', label: 'llama.cpp', hint: 'llama.cpp server model endpoints' },
+  { value: 'lm-studio', label: 'LM Studio', hint: 'LM Studio /v1/models + native metadata' },
+  { value: 'litellm', label: 'LiteLLM proxy', hint: 'LiteLLM proxy with rich model metadata' },
+  { value: 'proxy', label: 'New-API / One-API proxy', hint: 'Wire api read per model from the proxy' },
+  {
+    value: 'apple-foundation-models',
+    label: 'Apple Foundation Models',
+    hint: 'On-device model (Apple silicon only)',
+  },
+];
+
+/** True when `value` is a dialect omp's `ApiSchema` accepts. */
+export function isOmpProviderApi(value: unknown): value is OmpProviderApi {
+  return typeof value === 'string' && (PROVIDER_APIS as readonly string[]).includes(value);
+}
+
+/**
+ * True when the value is a credential the UI masked rather than a real key.
+ *
+ * The settings UI echoes a stored key back as `sk-••••…`; that placeholder must
+ * never be persisted, or a provider looks configured while it cannot
+ * authenticate. Shared by the client (which produces the mask) and the server
+ * (which is the last gate before the file).
+ */
+export function isMaskedApiKey(value: unknown): boolean {
+  return typeof value === 'string' && /•{3,}/.test(value);
+}
+
+/** True when `value` is an auth mode omp accepts. */
+export function isProviderAuthMode(value: unknown): value is ProviderAuthMode {
+  return value === 'apiKey' || value === 'none' || value === 'oauth';
+}
+
+/** True when `value` is a discovery type omp accepts. */
+export function isProviderDiscoveryType(value: unknown): value is ProviderDiscoveryType {
+  return PROVIDER_DISCOVERY_TYPES.some((entry) => entry.value === value);
+}
+
+/**
+ * omp's `api` for a provider whose endpoint is only recognizable by URL. omp
+ * accepts eleven dialects and no endpoint can be asked which one it speaks, so
+ * only the two hosts that are unambiguous by name are claimed here; everything
+ * else gets the OpenAI-compatible default that the model-listing probe already
+ * assumes. Anything else (Azure, Bedrock, Vertex, a Codex proxy) has to be
+ * picked by hand — guessing would write a dialect that misroutes every request.
+ */
+export function inferProviderApi(baseUrl: string): OmpProviderApi {
+  if (/anthropic\./i.test(baseUrl)) return 'anthropic-messages';
+  if (/generativelanguage\.googleapis\.com/i.test(baseUrl)) return 'google-generative-ai';
+  if (/openai\.azure\.com/i.test(baseUrl)) return 'azure-openai-responses';
+  if (/openrouter\.ai/i.test(baseUrl)) return 'openai-completions';
+  return 'openai-completions';
+}
+
+/**
+ * Why a provider's model list is empty — or `undefined` when the emptiness is
+ * unexplained and should read as a problem.
+ *
+ * A provider with no models is not automatically broken: an endpoint override
+ * leaves the model list to omp's own catalog, a discovery provider is listed by
+ * omp at runtime, and an authenticated login provider's models arrive with the
+ * agent's own snapshot. Printing "no models" for all of them made a correctly
+ * configured proxy look like a failed setup.
+ */
+export function providerEmptyReason(provider: {
+  modelSource?: ProviderModelSource;
+  discovery?: ProviderDiscoveryType;
+  auth?: ProviderAuthMode;
+}): string | undefined {
+  if (provider.discovery || provider.modelSource === 'discovery') {
+    return 'omp discovers this provider’s models live — they appear in the chat model picker, not here.';
+  }
+  if (provider.modelSource === 'override') {
+    // An override entry with no models and no credential is the one shape that
+    // genuinely cannot serve anything: omp has no key to reach the endpoint
+    // with. Naming the credential is the honest instruction.
+    return provider.auth === 'none'
+      ? 'Endpoint override — omp keeps its own model list for this provider. Use “fetch models” to add specific ids.'
+      : 'Endpoint override — omp keeps its own model list for this provider. It still needs a credential: use “connect” to supply one, or “fetch models” to add specific ids.';
+  }
+  if (provider.auth === 'none') {
+    return 'No models registered yet. This server is keyless, so use “fetch models” to list what it serves.';
+  }
+  return undefined;
+}
+

package/src/shared/lib/models/provider/glyph.test.ts

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The provider mark resolver is shared by the server (which builds provider
+ * rows) and the client (which renders them), and its two failure modes are both
+ * silent: a provider whose spelling does not fold onto its brand draws the wrong
+ * logo, and a provider with no mark at all would draw nothing. These lock the
+ * folding rules and the initials fallback.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { PROVIDER_GLYPHS } from '@/client/components/common/provider-icon/glyphs';
+import { providerInitials, resolveProviderGlyph } from '@/shared/lib/models/provider/glyph';
+
+/**
+ * Every provider id omp 18.3.0 ships (`KnownProvider`) plus the chamber's own
+ * additions. A provider added upstream appears here as one more id, and the
+ * coverage test below is what makes its missing mark a loud failure instead of a
+ * blank badge in the picker.
+ */
+const PROVIDER_IDS = [
+  'abliteration', 'aiand', 'aimlapi', 'alibaba-coding-plan', 'alibaba-token-plan', 'amazon-bedrock',
+  'anthropic', 'apple', 'azure', 'baseten', 'bedrock-mantle', 'cerebras', 'charm-hyper', 'cline-pass',
+  'cloudflare-ai-gateway', 'commandcode', 'coreweave', 'cursor', 'deepinfra', 'deepseek', 'devin',
+  'firepass', 'fireworks', 'github-copilot', 'gitlab-duo', 'gitlab-duo-agent', 'gmi-cloud', 'google',
+  'google-antigravity', 'google-gemini-cli', 'google-vertex', 'groq', 'huggingface', 'kilo', 'kimi-code',
+  'litellm', 'llama.cpp', 'lm-studio', 'local', 'meta', 'minimax', 'minimax-code', 'minimax-code-cn',
+  'mistral', 'moonshot', 'muse-code', 'nanogpt', 'novita', 'nvidia', 'ollama', 'ollama-cloud', 'openai',
+  'openai-codex', 'opencode-go', 'opencode-zen', 'openrouter', 'qianfan', 'qwen-portal', 'sakana',
+  'siliconflow', 'siliconflow-cn', 'singularityapi-dev', 'singularityapi-tech', 'stepfun', 'synthetic',
+  'together', 'typesafe', 'umans', 'venice', 'vercel-ai-gateway', 'vllm', 'wafer-serverless', 'web',
+  'xai', 'xai-oauth', 'xiaomi', 'xiaomi-token-plan-ams', 'xiaomi-token-plan-cn', 'xiaomi-token-plan-sgp',
+  'yolo-auto', 'zai', 'zenmux', 'zhipu-coding-plan',
+  // Chamber-side spellings that are not omp provider ids, plus the OAuth
+  // flavour ids the providers API actually serves (verified against a live
+  // /api/settings/providers response).
+  'kenari', 'agentrouter', 'claude', 'gemini', 'opencode', 'custom',
+  'zai-coding-plan', 'openai-codex-device', 'perplexity', 'tavily', 'kagi', 'exa', 'stencil',
+];
+
+describe('resolveProviderGlyph', () => {
+  test('a resolved mark exists in the glyph table', () => {
+    for (const id of PROVIDER_IDS) {
+      const name = resolveProviderGlyph(id);
+      if (name) expect(PROVIDER_GLYPHS[name]).toBeDefined();
+    }
+  });
+
+  test('every glyph draws something', () => {
+    // A bake that produced an empty body renders an invisible icon with no
+    // error anywhere — the provider simply loses its mark.
+    for (const [name, glyph] of Object.entries(PROVIDER_GLYPHS)) {
+      expect(glyph.viewBox, name).toMatch(/^[-\d.]+ [-\d.]+ [\d.]+ [\d.]+$/);
+      expect(/<(path|circle|rect|g)\b/.test(glyph.body), name).toBe(true);
+    }
+  });
+
+  test('no provider id leaves a blank badge', () => {
+    // The one promise of this module: a provider is drawn as its brand mark or
+    // as readable initials, never as an empty box.
+    for (const id of PROVIDER_IDS) {
+      const mark = resolveProviderGlyph(id);
+      expect(mark !== null || providerInitials(id).length > 0).toBe(true);
+    }
+  });
+
+  test('variants of one brand share that brand mark', () => {
+    expect(resolveProviderGlyph('minimax-code-cn')).toBe(resolveProviderGlyph('minimax'));
+    expect(resolveProviderGlyph('xiaomi-token-plan-ams')).toBe(resolveProviderGlyph('xiaomi'));
+    expect(resolveProviderGlyph('google-vertex')).toBe(resolveProviderGlyph('vertexai'));
+    expect(resolveProviderGlyph('openai-codex')).toBe(resolveProviderGlyph('codex'));
+    expect(resolveProviderGlyph('opencode-zen')).toBe(resolveProviderGlyph('opencode-go'));
+    expect(resolveProviderGlyph('gitlab-duo-agent')).toBe(resolveProviderGlyph('gitlab-duo'));
+  });
+
+  test('spelling differences fold to the same key', () => {
+    // omp reports ids, a models.yml slug is user-typed, and a display name is
+    // prose — all three reach this function.
+    for (const spelling of ['DeepSeek', 'deepseek', 'deep-seek', 'DEEP_SEEK', 'deepseek ']) {
+      expect(resolveProviderGlyph(spelling)).toBe('deepseek');
+    }
+  });
+
+  test('a stored icon key wins over the slug', () => {
+    // Legacy preset rows carry `icon: 'claude'` while their slug moved on.
+    expect(resolveProviderGlyph('claude', 'anthropic')).toBe('claude');
+  });
+
+  test('an unknown provider resolves to null rather than a wrong brand', () => {
+    expect(resolveProviderGlyph('my-private-gateway')).toBeNull();
+    expect(resolveProviderGlyph('')).toBeNull();
+    expect(resolveProviderGlyph(undefined, null)).toBeNull();
+  });
+});
+
+describe('providerInitials', () => {
+  test('takes one initial per word, joined with a single trailing dot', () => {
+    expect(providerInitials('Tooker')).toBe('t.');
+    expect(providerInitials('Toktok ID')).toBe('ti.');
+    expect(providerInitials('My Local Gateway')).toBe('ml.');
+  });
+
+  test('a hyphenated or underscored slug reads as separate words', () => {
+    expect(providerInitials('toktok-id')).toBe('ti.');
+    expect(providerInitials('tok_tok')).toBe('tt.');
+  });
+
+  test('an unlabelled provider still yields a visible badge', () => {
+    expect(providerInitials('')).toBe('?');
+    expect(providerInitials('   ')).toBe('?');
+  });
+});