@kabmo-labs/kabmo 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,227 @@
+/**
+ * Auto-fetch helpers for the providers settings: remote model listing via
+ * POST /api/settings/provider-models, and the REPLACE that follows it — the
+ * fetched list becomes the provider's model list, so an id the endpoint no
+ * longer serves leaves with it. The user's per-model choices (visibility,
+ * sampling) are carried over for the ids that survive.
+ */
+
+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;
+    /** Ids this fetch removed from models.yml because the endpoint dropped them. */
+    removedCount?: number;
+    reason?: string;
+  };
+}
+
+export interface ProviderModelsFetchRequest {
+  baseUrl: string;
+  apiKey?: string;
+  providerSlug?: string;
+  persistToOmp?: boolean;
+  /**
+   * Treat the listing as the provider's WHOLE model list: ids the endpoint no
+   * longer serves are removed from `models.yml`. Sent by "fetch models", whose
+   * answer describes the endpoint's current catalog; the add-provider path
+   * leaves it off, because it is registering an entry, not syncing one.
+   */
+  replaceModels?: 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(
+  request: ProviderModelsFetchRequest,
+): Promise<ProviderModelsFetchResult> {
+  try {
+    const response = await fetch('/api/settings/provider-models', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(request),
+    });
+    const data = await response.json() as ProviderModelsFetchResult;
+    if (!response.ok) {
+      return { ok: false, error: data?.error || `Request failed (HTTP ${response.status})` };
+    }
+    return data;
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : 'Network error while fetching models',
+    };
+  }
+}
+
+export interface ProviderModelsReplaceResult {
+  /** The provider's new model list: the fetched entries, in fetched order. */
+  models: ProviderModel[];
+  added: ProviderModel[];
+  addedCount: number;
+  /** Ids the endpoint no longer lists; the replace dropped them. */
+  removed: string[];
+  removedCount: 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',
+    };
+  }
+}
+
+/**
+ * Replace a provider's model list with a freshly fetched listing.
+ *
+ * "Fetch models" asks the endpoint what it serves NOW, so its answer is the
+ * list — an add-only merge left every id the endpoint had dropped behind, and
+ * the panel then offered models that no longer exist. The user's per-model
+ * choices (visibility, sampling config) live on the previous objects, so they
+ * are carried onto the entries that survive; a genuinely new id starts from
+ * the fetched entry.
+ */
+export function replaceProviderModels(
+  existing: ProviderModel[],
+  fetched: ProviderModel[],
+): ProviderModelsReplaceResult {
+  const previousById = new Map(existing.map((model) => [model.id, model]));
+  const seen = new Set<string>();
+  const models: ProviderModel[] = [];
+  const added: ProviderModel[] = [];
+  for (const model of fetched) {
+    if (!model.id || seen.has(model.id)) continue;
+    seen.add(model.id);
+    const previous = previousById.get(model.id);
+    if (!previous) {
+      const fresh = { ...model };
+      added.push(fresh);
+      models.push(fresh);
+      continue;
+    }
+    models.push({
+      ...model,
+      isVisible: previous.isVisible !== false,
+      ...(previous.temperature !== undefined ? { temperature: previous.temperature } : {}),
+      ...(previous.maxTokens !== undefined ? { maxTokens: previous.maxTokens } : {}),
+      ...(previous.topP !== undefined ? { topP: previous.topP } : {}),
+      ...(previous.reasoningEffort !== undefined ? { reasoningEffort: previous.reasoningEffort } : {}),
+    });
+  }
+  const removed = existing.filter((model) => !seen.has(model.id)).map((model) => model.id);
+  return { models, added, addedCount: added.length, removed, removedCount: removed.length };
+}
+
+/**
+ * Register newly added provider models on Kabmo's catalog.
+ *
+ * `isFavorite` is deliberately NOT sent: the picker derives favorites from the
+ * stored preference keys, so a catalog flag would be a second, silently
+ * ignored source of truth for the FAVORITES rail. A new provider's models are
+ * starred by the user, not by this sync.
+ */
+export async function syncProviderModelsToCatalog(
+  providerName: string,
+  models: ProviderModel[],
+): Promise<void> {
+  try {
+    await Promise.all(
+      models.map((model) =>
+        fetch('/api/models', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            actionType: 'addModel',
+            model: {
+              id: model.id,
+              name: model.name,
+              provider: providerName,
+              contextWindow: model.contextWindow?.split(' ')[0] || '128K',
+              thinkingLevel: 'Default',
+              capabilities: ['Tool calling', 'Reasoning'],
+              inputFormats: ['text'],
+              outputFormats: ['text'],
+            },
+          }),
+        }),
+      ),
+    );
+    notifyModelsUpdated();
+  } catch (error) {
+    console.error('Failed to sync provider models to catalog:', error);
+  }
+}

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

@@ -0,0 +1,198 @@
+/**
+ * @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, providerFetchBlockReason } 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();
+  });
+});
+
+describe('providerFetchBlockReason', () => {
+  test('a models.yml provider with an endpoint may fetch', () => {
+    // The regression: the registry built these entries without a `baseUrl`, so
+    // the button was disabled for the one set of providers whose endpoint the
+    // Kabmo actually knows.
+    expect(providerFetchBlockReason({ baseUrl: 'https://kenari.id/v1', modelSource: 'fetch' })).toBeUndefined();
+  });
+
+  test('a login provider names the endpoint as the reason, not the shape', () => {
+    // omp owns the URL of an `omp auth` provider, so there is nothing to probe.
+    const reason = providerFetchBlockReason({});
+    expect(reason).toContain('no endpoint');
+  });
+
+  test('a discovery provider is blocked even though it has an endpoint', () => {
+    // Fetching here would write a snapshot beside the list omp resolves live.
+    const reason = providerFetchBlockReason({ baseUrl: 'http://127.0.0.1:11434', discovery: 'ollama' });
+    expect(reason).toContain('lists this provider’s models itself');
+    expect(providerFetchBlockReason({ baseUrl: 'http://127.0.0.1:11434', modelSource: 'discovery' })).toBeDefined();
+  });
+
+  test('an endpoint override is NOT blocked — adding specific ids is the point', () => {
+    expect(providerFetchBlockReason({ baseUrl: 'https://proxy.example.com', modelSource: 'override' })).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
+ *   Kabmo 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 Kabmo 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;
+}