ompchamber 2.0.2 → 3.1.0

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

@@ -0,0 +1,200 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Provider spelling -> brand glyph, plus the initials fallback for a provider
+ * that publishes no logo.
+ *
+ * A provider reaches this module as whatever string omp reported: a login
+ * provider id (`google-vertex`), a models.yml slug the user typed
+ * (`my-gateway`), a legacy chamber icon key (`claude`), or a display name
+ * (`DeepSeek`). All four must land on the same mark, so lookup folds the input
+ * to lowercase alphanumerics and matches it against this table.
+ *
+ * The table is DATA, not a chain of `if`s: `minimax-code-cn` is the same brand
+ * as `minimax`, and a new variant belongs here as one more row rather than as
+ * another branch at every call site.
+ *
+ * Pure and dependency-free so the server (which builds provider rows) and the
+ * client (which renders them) resolve a provider identically.
+ */
+
+/**
+ * Normalised provider spelling -> glyph name in `PROVIDER_GLYPHS`.
+ *
+ * Keys are lowercase alphanumerics only (`google-vertex` is `googlevertex`).
+ * Values name an entry in the glyph table, or a brand whose mark stands for
+ * several providers (Bedrock draws Amazon's mark).
+ */
+export const PROVIDER_GLYPH_ALIASES: Readonly<Record<string, string>> = {
+  abliteration: 'abliteration',
+  aiand: 'aiand',
+  aimlapi: 'aimlapi',
+  alibaba: 'alibaba',
+  alibabacloud: 'alibaba',
+  alibabacodingplan: 'alibaba',
+  alibabatokenplan: 'alibaba',
+  amazon: 'amazon',
+  amazonbedrock: 'amazon',
+  anthropic: 'anthropic',
+  antigravity: 'antigravity',
+  apple: 'apple',
+  aws: 'amazon',
+  azure: 'azure',
+  azureai: 'azure',
+  baidu: 'baidu',
+  baseten: 'baseten',
+  bedrock: 'amazon',
+  bedrockmantle: 'amazon',
+  cerebras: 'cerebras',
+  charm: 'charm',
+  charmhyper: 'charm',
+  chatglm: 'zai',
+  claude: 'claude',
+  claudecode: 'claude',
+  cline: 'cline',
+  clinepass: 'cline',
+  cloudflare: 'cloudflare',
+  cloudflareaigateway: 'cloudflare',
+  codex: 'codex',
+  commandcode: 'commandcode',
+  copilot: 'githubcopilot',
+  coreweave: 'coreweave',
+  cursor: 'cursor',
+  deepinfra: 'deepinfra',
+  deepseek: 'deepseek',
+  devin: 'devin',
+  ernie: 'baidu',
+  firepass: 'fireworks',
+  fireworks: 'fireworks',
+  gemini: 'gemini',
+  geminicli: 'geminicli',
+  githubcopilot: 'githubcopilot',
+  gitlab: 'gitlab',
+  gitlabduo: 'gitlab',
+  gitlabduoagent: 'gitlab',
+  glm: 'zai',
+  gmicloud: 'gmicloud',
+  google: 'google',
+  googleantigravity: 'antigravity',
+  googlecloud: 'google',
+  googlegemini: 'gemini',
+  googlegeminicli: 'geminicli',
+  googlevertex: 'vertexai',
+  grok: 'xai',
+  groq: 'groq',
+  huggingface: 'huggingface',
+  kenari: 'kenari',
+  kilo: 'kilocode',
+  kilocode: 'kilocode',
+  kimi: 'kimi',
+  kimicode: 'kimi',
+  litellm: 'litellm',
+  llama: 'meta',
+  llamacpp: 'llamacpp',
+  lmstudio: 'lmstudio',
+  meta: 'meta',
+  metaai: 'metaai',
+  microsoftazure: 'azure',
+  minimax: 'minimax',
+  minimaxcode: 'minimax',
+  minimaxcodecn: 'minimax',
+  mistral: 'mistral',
+  mistralai: 'mistral',
+  moonshot: 'moonshot',
+  moonshotai: 'moonshot',
+  musecode: 'metaai',
+  nanogpt: 'nanogpt',
+  novita: 'novita',
+  nvidia: 'nvidia',
+  ollama: 'ollama',
+  ollamacloud: 'ollama',
+  openai: 'openai',
+  openaicodex: 'codex',
+  opencode: 'opencode',
+  opencodego: 'opencode',
+  opencodezen: 'opencode',
+  openrouter: 'openrouter',
+  qianfan: 'baidu',
+  qwen: 'qwen',
+  qwenportal: 'qwen',
+  sakana: 'sakana',
+  sakanaai: 'sakana',
+  siliconcloud: 'siliconcloud',
+  siliconflow: 'siliconcloud',
+  siliconflowcn: 'siliconcloud',
+  singularity: 'singularity',
+  singularityapidev: 'singularity',
+  singularityapitech: 'singularity',
+  stepfun: 'stepfun',
+  synthetic: 'synthetic',
+  together: 'together',
+  togetherai: 'together',
+  venice: 'venice',
+  vercel: 'vercel',
+  vercelaigateway: 'vercel',
+  vertexai: 'vertexai',
+  vllm: 'vllm',
+  wafer: 'wafer',
+  waferserverless: 'wafer',
+  xai: 'xai',
+  xaioauth: 'xai',
+  xiaomi: 'xiaomi',
+  xiaomitokenplanams: 'xiaomi',
+  xiaomitokenplancn: 'xiaomi',
+  xiaomitokenplansgp: 'xiaomi',
+  yolo: 'yoloauto',
+  yoloauto: 'yoloauto',
+  zai: 'zai',
+  zaicodingplan: 'zai',
+  openaicodexdevice: 'codex',
+  perplexity: 'perplexity',
+  tavily: 'tavily',
+  kagi: 'kagi',
+  exa: 'exa',
+  stencil: 'stencil',
+  zenmux: 'zenmux',
+  zhipu: 'zhipu',
+  zhipucodingplan: 'zhipu',
+};
+
+/**
+ * The glyph name for a provider, or `null` when no brand mark is registered —
+ * the caller then draws the initials badge instead of an empty box.
+ *
+ * Candidates are tried in order and each is folded to lowercase alphanumerics
+ * first, so a stored legacy icon key (`claude`) still resolves after the
+ * provider's slug changes. Pass the provider's own `icon` field before its slug
+ * to keep that precedence.
+ */
+export function resolveProviderGlyph(
+  ...candidates: Array<string | null | undefined>
+): string | null {
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const key = candidate.toLowerCase().replace(/[^a-z0-9]/g, '');
+    const alias = key ? PROVIDER_GLYPH_ALIASES[key] : undefined;
+    if (alias) return alias;
+  }
+  return null;
+}
+
+/**
+ * Fallback badge text for a provider with no brand mark: the initial of each of
+ * the label's first two title-cased words, joined and closed with a single dot —
+ * `Tooker` -> `t.`, `Toktok ID` -> `ti.`.
+ *
+ * Lowercase because the badge renders beside lowercase UI labels, and capped at
+ * two initials because a third overflows the badge at icon size.
+ */
+export function providerInitials(label: string): string {
+  const words = label.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+  if (words.length === 0) return '?';
+  const initials = words
+    .slice(0, 2)
+    .map((word) => word.charAt(0).toLowerCase())
+    .join('');
+  return `${initials}.`;
+}

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

@@ -5,26 +5,49 @@
  */
 
 import type { ProviderModel } from '@/shared/types';
+import type {
+  OmpProviderApi,
+  ProviderAuthMode,
+  ProviderDiscoveryType,
+} from '@/shared/types/settings/provider';
+import type { ProviderThinkingEffort } from '@/shared/lib/models/provider/dialect';
 import { notifyModelsUpdated } from '@/shared/lib/models/client';
 
 export interface ProviderModelsFetchResult {
   ok: boolean;
   models?: ProviderModel[];
   error?: string;
-  omp?: { written: boolean; addedCount: number; backfilledCount: number; reason?: string };
+  omp?: {
+    written: boolean;
+    addedCount: number;
+    backfilledCount: number;
+    reason?: string;
+  };
+}
+
+export interface ProviderModelsFetchRequest {
+  baseUrl: string;
+  apiKey?: string;
+  providerSlug?: string;
+  persistToOmp?: boolean;
+  /** Wire dialect to probe and to write into models.yml. */
+  api?: OmpProviderApi;
+  /** omp auth mode; `none` marks a keyless local server. */
+  auth?: ProviderAuthMode;
+  /** Register the provider for omp's own live discovery — no listing here. */
+  discovery?: ProviderDiscoveryType;
+  /** Register the provider WITHOUT listing models (endpoint override only). */
+  registerOnly?: boolean;
 }
 
 export async function fetchProviderModelsRemote(
-  baseUrl: string,
-  apiKey?: string,
-  providerSlug?: string,
-  persistToOmp = false,
+  request: ProviderModelsFetchRequest,
 ): Promise<ProviderModelsFetchResult> {
   try {
     const response = await fetch('/api/settings/provider-models', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ baseUrl, apiKey, providerSlug, persistToOmp }),
+      body: JSON.stringify(request),
     });
     const data = await response.json() as ProviderModelsFetchResult;
     if (!response.ok) {
@@ -45,6 +68,68 @@ export interface ProviderModelsMergeResult {
   addedCount: number;
 }
 
+/** One model registered by hand — the Add Model dialog's payload. */
+export interface ManualModelRequest {
+  provider: string;
+  id: string;
+  name?: string;
+  /** Token counts, not the compact labels a listing produces. */
+  contextWindow?: number;
+  maxTokens?: number;
+  reasoning?: boolean;
+  imageInput?: boolean;
+  /** USD per 1M tokens; both input and output are needed for a cost to be written. */
+  costInput?: number;
+  costOutput?: number;
+  costCacheRead?: number;
+  costCacheWrite?: number;
+  /** Reasoning ladder this model accepts; omitted means "leave omp's default". */
+  efforts?: ProviderThinkingEffort[];
+  /** Only used when the provider has no models.yml entry yet. */
+  baseUrl?: string;
+  apiKey?: string;
+  auth?: ProviderAuthMode;
+}
+
+export interface ManualModelResult {
+  success: boolean;
+  written: boolean;
+  addedModels?: string[];
+  backfilledModels?: string[];
+  /** The provider already registers this id; nothing was overwritten. */
+  alreadyKnown?: boolean;
+  reason?: string;
+  error?: string;
+}
+
+/**
+ * Register one model in models.yml by hand. Unlike the auto-fetch this does not
+ * need a listing endpoint — the id and its metadata come from the user — so it
+ * is the path for a gateway model its `/models` route omits, an Azure
+ * deployment name, or any provider omp cannot enumerate.
+ */
+export async function addProviderModel(request: ManualModelRequest): Promise<ManualModelResult> {
+  try {
+    const response = await fetch('/api/settings/provider-model', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(request),
+    });
+    const data = await response.json() as ManualModelResult;
+    if (!response.ok) {
+      return { ...data, success: false, written: false, error: data?.error || data?.reason };
+    }
+    notifyModelsUpdated();
+    return data;
+  } catch (error) {
+    return {
+      success: false,
+      written: false,
+      error: error instanceof Error ? error.message : 'Network error while adding the model',
+    };
+  }
+}
+
 /**
  * Existing entries pass through untouched (visibility/config survive); the
  * chat model catalog is synced from the newly added entries only.

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

@@ -0,0 +1,172 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The Add Provider picker's rules, which are all silent when wrong: a preset
+ * offered for a CONNECTED provider produces a second `models.yml` entry under
+ * the same slug (the upsert then writes into the live one), and a preset
+ * dropped while its provider is only DISCONNECTED makes the switch that hid it
+ * unreachable. The dialect fields are checked too — a preset whose `api` omp
+ * does not know would disable every custom provider in the file.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  buildAvailableProviderPresets,
+  configuredProviderSlugs,
+  groupProviderPresets,
+} from '@/shared/lib/models/provider/presets';
+import { PROVIDER_APIS, providerEmptyReason } from '@/shared/lib/models/provider/dialect';
+import { PRESET_NEW_PROVIDERS } from '@/client/data/settings/provider';
+import type { PresetProviderOption, ProviderItem } from '@/shared/types/settings/provider';
+
+function provider(overrides: Partial<ProviderItem> & { slug: string }): ProviderItem {
+  return {
+    id: `id-${overrides.slug}`,
+    name: overrides.slug,
+    icon: overrides.slug,
+    status: 'connected',
+    configuredIn: 'models.yml',
+    models: [],
+    ...overrides,
+  } as ProviderItem;
+}
+
+const PRESETS: PresetProviderOption[] = [
+  { id: 'openai', name: 'OpenAI', slug: 'openai', icon: 'openai', defaultUrl: 'https://api.openai.com/v1', group: 'Frontier APIs' },
+  { id: 'groq', name: 'Groq', slug: 'groq', icon: 'groq', defaultUrl: 'https://api.groq.com/openai/v1', group: 'Frontier APIs' },
+  { id: 'ollama', name: 'Ollama', slug: 'ollama', icon: 'ollama', defaultUrl: 'http://127.0.0.1:11434', auth: 'none', discovery: 'ollama', group: 'Local & self-hosted' },
+];
+
+describe('buildAvailableProviderPresets', () => {
+  test('drops a non-bundled preset whose slug already has an endpoint', () => {
+    // A second entry under one slug is the same entry to omp; that provider is
+    // managed from the sidebar instead.
+    const available = buildAvailableProviderPresets(
+      [provider({ slug: 'openai', baseUrl: 'https://api.openai.com/v1' })],
+      PRESETS,
+    );
+    expect(available.map((entry) => entry.slug)).toEqual(['groq', 'ollama']);
+  });
+
+  test('keeps a preset whose provider omp merely KNOWS', () => {
+    // omp reports ~60 providers it knows with no endpoint and no credential;
+    // treating those as configured hid every gateway preset — the one case
+    // where the user wants to bring their own key.
+    const available = buildAvailableProviderPresets(
+      [provider({ slug: 'openai', status: 'disconnected', disabled: true })],
+      PRESETS,
+    );
+    expect(available.map((entry) => entry.slug)).toEqual(['openai', 'groq', 'ollama']);
+  });
+
+  test('keeps a bundled preset even when its provider is configured', () => {
+    // An override for a provider omp already ships is the documented way to
+    // point it at a proxy, and the writer is add-only, so re-offering is safe.
+    const available = buildAvailableProviderPresets(
+      [provider({ slug: 'azure', status: 'connected', baseUrl: 'https://x.openai.azure.com' })],
+      [{ ...PRESETS[0], slug: 'azure', id: 'azure', bundled: true }],
+    );
+    expect(available.map((entry) => entry.slug)).toEqual(['azure']);
+  });
+
+  test('never offers one slug twice', () => {
+    const available = buildAvailableProviderPresets(
+      [provider({ slug: 'ollama', status: 'disconnected' })],
+      PRESETS,
+    );
+    const slugs = available.map((entry) => entry.slug);
+    expect(new Set(slugs).size).toBe(slugs.length);
+  });
+});
+
+describe('groupProviderPresets', () => {
+  test('buckets by group in declaration order and keeps members in order', () => {
+    const groups = groupProviderPresets(PRESETS);
+    expect(groups.map((entry) => entry.group)).toEqual(['Frontier APIs', 'Local & self-hosted']);
+    expect(groups[0].options.map((entry) => entry.slug)).toEqual(['openai', 'groq']);
+  });
+});
+
+describe('shipped presets', () => {
+  test('every declared api is one omp accepts', () => {
+    for (const preset of PRESET_NEW_PROVIDERS) {
+      if (!preset.api) continue;
+      expect(PROVIDER_APIS).toContain(preset.api);
+    }
+  });
+
+  test('every preset carries a group and a unique id', () => {
+    const ids = PRESET_NEW_PROVIDERS.map((preset) => preset.id);
+    expect(new Set(ids).size).toBe(ids.length);
+    for (const preset of PRESET_NEW_PROVIDERS) {
+      expect(preset.group.length).toBeGreaterThan(0);
+    }
+  });
+
+  test('a discovery preset declares a keyless or authenticated shape, never neither', () => {
+    // omp needs a dialect for every discovery provider except `proxy`, which
+    // reports one per model; a preset without either would be rejected on load.
+    for (const preset of PRESET_NEW_PROVIDERS) {
+      if (!preset.discovery) continue;
+      expect(preset.api !== undefined || preset.discovery === 'proxy').toBe(true);
+    }
+  });
+
+  test('a built-in local engine preset is keyless', () => {
+    // omp's implicit ollama/llama.cpp/lm-studio engines are keyless; a preset
+    // that omitted `auth: none` would be registered as a provider omp reports
+    // as unconfigured. LiteLLM is deliberately excluded — it is a proxy that
+    // authenticates with its own master key.
+    const engines = PRESET_NEW_PROVIDERS.filter(
+      (preset) => preset.discovery === 'ollama'
+        || preset.discovery === 'llama.cpp'
+        || preset.discovery === 'lm-studio',
+    );
+    expect(engines.length).toBe(3);
+    for (const preset of engines) {
+      expect(preset.auth).toBe('none');
+    }
+  });
+});
+
+describe('configuredProviderSlugs', () => {
+  test('names only the providers that already own a slug', () => {
+    // omp reports ~60 providers it merely knows; naming those as taken would
+    // block the Add Provider dialog from ever configuring one of them.
+    const slugs = configuredProviderSlugs([
+      provider({ slug: 'openai', status: 'disconnected' }),
+      provider({ slug: 'azure', status: 'disconnected', baseUrl: 'https://x.openai.azure.com' }),
+      provider({ slug: 'deepseek' }),
+    ]);
+    expect(slugs).toEqual(['azure', 'deepseek']);
+  });
+});
+
+describe('providerEmptyReason', () => {
+  test('explains a discovery provider without calling it empty', () => {
+    expect(providerEmptyReason({ discovery: 'lm-studio' })).toContain('discovers this provider');
+    expect(providerEmptyReason({ modelSource: 'discovery' })).toContain('discovers this provider');
+  });
+
+  test('an override names the missing credential rather than only the shape', () => {
+    const withKey = providerEmptyReason({ modelSource: 'override' });
+    expect(withKey).toContain('Endpoint override');
+    expect(withKey).toContain('still needs a credential');
+
+    // A keyless override has nothing missing, so it must not claim one is.
+    const keyless = providerEmptyReason({ modelSource: 'override', auth: 'none' });
+    expect(keyless).toContain('Endpoint override');
+    expect(keyless).not.toContain('still needs a credential');
+  });
+
+  test('an unexplained empty list stays unexplained', () => {
+    // A hosted provider with no models is a problem; inventing a reassuring
+    // reason for it would hide the failure.
+    expect(providerEmptyReason({})).toBeUndefined();
+    expect(providerEmptyReason({ modelSource: 'fetch' })).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Which presets the Add Provider picker may offer, and how they are grouped.
+ *
+ * The rule differs by preset kind, because the two kinds write different things:
+ *
+ * - A **bundled** preset names a provider omp already ships (Anthropic, Azure,
+ *   Bedrock, Vertex, Codex). Its entry in `models.yml` is an OVERRIDE — omp
+ *   keeps serving its own model list and only the endpoint changes — and the
+ *   writer is add-only, so re-offering it is safe and is the documented way to
+ *   point a built-in provider at a proxy.
+ * - Any other preset creates a provider entry of its own, so a slug that is
+ *   already DEFINED — connected, or carrying its own `baseUrl` in models.yml or
+ *   the chamber overlay — is not re-offered; that provider is managed from the
+ *   sidebar, which can reconnect it and edit its endpoint.
+ *
+ * `status` alone is the wrong test: omp reports ~60 providers it merely
+ * KNOWS (`get_login_providers`), which are `disconnected` with no endpoint and
+ * no credential. Treating those as "already added" hid every gateway preset —
+ * the one case where a user wants to bring their own key.
+ */
+
+import type { PresetProviderOption, ProviderItem } from '@/shared/types/settings/provider';
+
+/**
+ * True when the provider already owns this slug in a config file — connected,
+ * or carrying its own `baseUrl` from models.yml or the chamber overlay.
+ */
+export function providerOwnsSlug(provider: ProviderItem | undefined): boolean {
+  return provider !== undefined && (provider.status === 'connected' || Boolean(provider.baseUrl));
+}
+
+/**
+ * Slugs already DEFINED in a config file — the ones a new provider entry would
+ * collide with. Deliberately not every provider omp reports: it lists ~60 it
+ * merely knows (`get_login_providers`), all `disconnected` with no endpoint, and
+ * treating those as taken blocks the user from ever configuring them.
+ */
+export function configuredProviderSlugs(providers: ProviderItem[]): string[] {
+  return providers
+    .filter((provider) => provider.slug.trim().length > 0 && providerOwnsSlug(provider))
+    .map((provider) => provider.slug);
+}
+
+export function buildAvailableProviderPresets(
+  providers: ProviderItem[],
+  presets: PresetProviderOption[],
+): PresetProviderOption[] {
+  const bySlug = new Map<string, ProviderItem>();
+  for (const provider of providers) {
+    const slug = provider.slug.trim().toLowerCase();
+    if (slug) bySlug.set(slug, provider);
+  }
+  const seenSlugs = new Set<string>();
+  const available: PresetProviderOption[] = [];
+
+  for (const preset of presets) {
+    const slug = preset.slug.trim().toLowerCase();
+    if (seenSlugs.has(slug)) continue;
+    if (!preset.bundled && providerOwnsSlug(bySlug.get(slug))) continue;
+    seenSlugs.add(slug);
+    available.push(preset);
+  }
+
+  return available;
+}
+
+/** Presets bucketed into their `group`, in the order the presets declare them. */
+export function groupProviderPresets(
+  presets: PresetProviderOption[],
+): Array<{ group: string; options: PresetProviderOption[] }> {
+  const groups: Array<{ group: string; options: PresetProviderOption[] }> = [];
+  for (const preset of presets) {
+    const existing = groups.find((entry) => entry.group === preset.group);
+    if (existing) existing.options.push(preset);
+    else groups.push({ group: preset.group, options: [preset] });
+  }
+  return groups;
+}