fix(tui): filter unsupported catalog providers

Author: 7Sageer

apps/kimi-code/scripts/update-catalog.mjs

@@ -14,7 +14,7 @@ const outFile = resolve(scriptDir, "../src/built-in-catalog.ts");
 const modelsUrl = process.env.MODELS_DEV_URL || "https://models.dev/api.json";
 
 const KEEP_PROVIDER = new Set(["id", "name", "api", "env", "npm", "type", "models"]);
-const KEEP_MODEL = new Set(["id", "name", "limit", "tool_call", "reasoning", "modalities"]);
+const KEEP_MODEL = new Set(["id", "name", "family", "limit", "tool_call", "reasoning", "modalities"]);
 
 function stripModel(model) {
   if (typeof model !== "object" || model === null) return undefined;

apps/kimi-code/src/built-in-catalog.ts

@@ -42,7 +42,6 @@ import {
   catalogModelToAlias,
   catalogProviderModels,
   CatalogFetchError,
-  DEFAULT_CATALOG_URL,
   fetchCatalog,
   inferWireType,
   loadBuiltInCatalog,
@@ -224,6 +223,7 @@ import {
 import { formatBackgroundAgentTranscript } from './utils/background-agent-status';
 import { formatBackgroundTaskTranscript } from './utils/background-task-status';
 import { hasDispose, isExpandable, isPlanExpandable } from './utils/component-capabilities';
+import { resolveConnectCatalogRequest } from './utils/connect-catalog';
 import {
   argsRecord,
   formatErrorMessage,
@@ -4344,6 +4344,7 @@ export class KimiTUI {
         selectedValue,
         currentThinking: this.state.appState.thinking,
         colors: this.state.theme.colors,
+        searchable: true,
         onSelect: ({ alias, thinking }) => {
           this.restoreEditor();
           void this.performModelSwitch(alias, thinking);
@@ -5064,10 +5065,7 @@ export class KimiTUI {
   // (context size, capabilities) comes from the catalog, so users do not
   // hand-write it.
   private async handleConnectCommand(args: string): Promise<void> {
-    const trimmed = args.trim();
-    const urlMatch = trimmed.match(/--url(?:=|\s+)(\S+)/);
-    const url =
-      urlMatch?.[1] ?? (/^https?:\/\/\S+$/.test(trimmed) ? trimmed : DEFAULT_CATALOG_URL);
+    const { url, allowBuiltInFallback } = resolveConnectCatalogRequest(args);
 
     const controller = new AbortController();
     const cancel = (): void => {
@@ -5085,13 +5083,18 @@ export class KimiTUI {
         spinner.stop({ ok: false, label: 'Aborted.' });
       } else {
         const hint = error instanceof CatalogFetchError ? ` (HTTP ${error.status})` : '';
-        const fallback = loadBuiltInCatalog(BUILT_IN_CATALOG_JSON);
-        if (fallback !== undefined) {
-          spinner.stop({ ok: true, label: 'Using built-in catalog (offline mode).' });
-          catalog = fallback;
-        } else {
+        if (!allowBuiltInFallback) {
           spinner.stop({ ok: false, label: 'Failed to load catalog.' });
           this.showError(`Failed to fetch catalog${hint}: ${formatErrorMessage(error)}`);
+        } else {
+          const fallback = loadBuiltInCatalog(BUILT_IN_CATALOG_JSON);
+          if (fallback !== undefined) {
+            spinner.stop({ ok: true, label: 'Using built-in catalog (offline mode).' });
+            catalog = fallback;
+          } else {
+            spinner.stop({ ok: false, label: 'Failed to load catalog.' });
+            this.showError(`Failed to fetch catalog${hint}: ${formatErrorMessage(error)}`);
+          }
         }
       }
     } finally {
@@ -5118,6 +5121,7 @@ export class KimiTUI {
     if (apiKey === undefined) return;
 
     const wire = inferWireType(entry);
+    if (wire === undefined) return;
     const baseUrl = catalogBaseUrl(entry, wire);
 
     // Remove stale provider config first so old model aliases are fully
@@ -5258,6 +5262,7 @@ export class KimiTUI {
   private promptCatalogProviderSelection(catalog: Catalog): Promise<string | undefined> {
     return new Promise((resolve) => {
       const options: ChoiceOption[] = Object.entries(catalog)
+        .filter(([, entry]) => inferWireType(entry) !== undefined)
         .map(([id, entry]) => ({
           value: id,
           label: entry.name ?? id,
@@ -5349,6 +5354,7 @@ export class KimiTUI {
         currentValue: firstAlias,
         currentThinking: initialThinking,
         colors: this.state.theme.colors,
+        searchable: true,
         onSelect: ({ alias, thinking }) => {
           this.restoreEditor();
           resolve({ alias, thinking });

apps/kimi-code/src/tui/kimi-tui.ts

@@ -0,0 +1,21 @@
+import { DEFAULT_CATALOG_URL } from '@moonshot-ai/kimi-code-sdk';
+
+const CATALOG_URL_FLAG_RE = /--url(?:=|\s+)(\S+)/;
+const BARE_HTTP_URL_RE = /^https?:\/\/\S+$/;
+
+export interface ConnectCatalogRequest {
+  readonly url: string;
+  readonly allowBuiltInFallback: boolean;
+}
+
+export function resolveConnectCatalogRequest(args: string): ConnectCatalogRequest {
+  const trimmed = args.trim();
+  const urlMatch = CATALOG_URL_FLAG_RE.exec(trimmed);
+  const bareUrl = BARE_HTTP_URL_RE.test(trimmed) ? trimmed : undefined;
+  const explicitUrl = urlMatch?.[1] ?? bareUrl;
+
+  return {
+    url: explicitUrl ?? DEFAULT_CATALOG_URL,
+    allowBuiltInFallback: explicitUrl === undefined,
+  };
+}

apps/kimi-code/src/tui/utils/connect-catalog.ts

@@ -34,6 +34,21 @@ interface FeedbackDriver extends MessageDriver {
   promptFeedbackInput(): Promise<string | undefined>;
 }
 
+interface ModelSelectorDriver extends MessageDriver {
+  runModelSelector(
+    models: Record<
+      string,
+      {
+        provider: string;
+        model: string;
+        maxContextSize: number;
+        displayName?: string;
+        capabilities?: string[];
+      }
+    >,
+  ): Promise<{ alias: string; thinking: boolean } | undefined>;
+}
+
 function makeStartupInput(): KimiTUIStartupInput {
   return {
     cliOptions: {
@@ -1017,6 +1032,12 @@ describe('KimiTUI message flow', () => {
     const pickerOutput = stripSgr((picker as ModelSelectorComponent).render(120).join('\n'));
     expect(pickerOutput).toContain('Kimi K2 (Kimi Code) ← current');
     expect(pickerOutput).toContain('❯ Kimi Turbo (Kimi Code)');
+    (picker as ModelSelectorComponent).handleInput('t');
+    (picker as ModelSelectorComponent).handleInput('u');
+    const filteredOutput = stripSgr((picker as ModelSelectorComponent).render(120).join('\n'));
+    expect(filteredOutput).toContain('Search: tu');
+    expect(filteredOutput).toContain('Kimi Turbo (Kimi Code)');
+    expect(filteredOutput).not.toContain('Kimi K2 (Kimi Code)');
     (picker as ModelSelectorComponent).handleInput('\u001B[D');
     (picker as ModelSelectorComponent).handleInput('\r');
 
@@ -1028,6 +1049,41 @@ describe('KimiTUI message flow', () => {
     expect(driver.state.appState.thinking).toBe(true);
   });
 
+  it('enables search in the shared model selector helper', async () => {
+    const { driver } = await makeDriver();
+    const selectorDriver = driver as unknown as ModelSelectorDriver;
+    const selection = selectorDriver.runModelSelector({
+      alpha: {
+        provider: 'managed:kimi-code',
+        model: 'kimi-alpha',
+        maxContextSize: 100,
+        displayName: 'Kimi Alpha',
+        capabilities: ['thinking'],
+      },
+      turbo: {
+        provider: 'managed:kimi-code',
+        model: 'kimi-turbo',
+        maxContextSize: 100,
+        displayName: 'Kimi Turbo',
+        capabilities: ['thinking'],
+      },
+    });
+
+    const picker = driver.state.editorContainer.children[0];
+    expect(picker).toBeInstanceOf(ModelSelectorComponent);
+    (picker as ModelSelectorComponent).handleInput('t');
+    (picker as ModelSelectorComponent).handleInput('u');
+
+    const output = stripSgr((picker as ModelSelectorComponent).render(120).join('\n'));
+    expect(output).toContain('Search: tu');
+    expect(output).toContain('Kimi Turbo (Kimi Code)');
+    expect(output).not.toContain('Kimi Alpha (Kimi Code)');
+
+    (picker as ModelSelectorComponent).handleInput('\u001B');
+    (picker as ModelSelectorComponent).handleInput('\u001B');
+    await expect(selection).resolves.toBeUndefined();
+  });
+
   it('deletes Kitty inline images when /new clears the transcript', async () => {
     setCapabilities({ images: 'kitty', trueColor: true, hyperlinks: true });
     const { driver, harness } = await makeDriver(makeSession({ id: 'ses-1' }));

apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts

@@ -0,0 +1,32 @@
+import { DEFAULT_CATALOG_URL } from '@moonshot-ai/kimi-code-sdk';
+import { describe, expect, it } from 'vitest';
+
+import { resolveConnectCatalogRequest } from '#/tui/utils/connect-catalog';
+
+describe('resolveConnectCatalogRequest', () => {
+  it('uses the default catalog and permits built-in fallback when no URL is specified', () => {
+    expect(resolveConnectCatalogRequest('')).toEqual({
+      url: DEFAULT_CATALOG_URL,
+      allowBuiltInFallback: true,
+    });
+    expect(resolveConnectCatalogRequest('ignored text')).toEqual({
+      url: DEFAULT_CATALOG_URL,
+      allowBuiltInFallback: true,
+    });
+  });
+
+  it('treats explicit catalog URLs as authoritative', () => {
+    expect(resolveConnectCatalogRequest('--url=https://internal.example/catalog.json')).toEqual({
+      url: 'https://internal.example/catalog.json',
+      allowBuiltInFallback: false,
+    });
+    expect(resolveConnectCatalogRequest('--url https://internal.example/catalog.json')).toEqual({
+      url: 'https://internal.example/catalog.json',
+      allowBuiltInFallback: false,
+    });
+    expect(resolveConnectCatalogRequest('https://internal.example/catalog.json')).toEqual({
+      url: 'https://internal.example/catalog.json',
+      allowBuiltInFallback: false,
+    });
+  });
+});

apps/kimi-code/test/tui/utils/connect-catalog.test.ts

@@ -9,6 +9,7 @@ import type { ProviderType } from './providers';
 export interface CatalogModelEntry {
   readonly id?: string;
   readonly name?: string;
+  readonly family?: string;
   readonly limit?: { readonly context?: number; readonly output?: number };
   readonly tool_call?: boolean;
   readonly reasoning?: boolean;
@@ -56,12 +57,28 @@ function isWireType(value: unknown): value is ProviderType {
   return typeof value === 'string' && (KNOWN_WIRE_TYPES as readonly string[]).includes(value);
 }
 
+function hasEmbeddingMarker(value: string | undefined): boolean {
+  if (value === undefined) return false;
+  const lower = value.toLowerCase();
+  return lower.includes('embedding') || /(?:^|[-_/])embed(?:$|[-_/])/.test(lower);
+}
+
+function isUsableChatModel(model: CatalogModelEntry): boolean {
+  const outputModalities = model.modalities?.output;
+  if (outputModalities !== undefined && !outputModalities.includes('text')) return false;
+  return (
+    !hasEmbeddingMarker(model.family) &&
+    !hasEmbeddingMarker(model.id) &&
+    !hasEmbeddingMarker(model.name)
+  );
+}
+
 /**
- * Resolves a catalog provider entry to a wire type. Honors an explicit `type`,
- * otherwise infers from `npm`/`id`. The openai vs openai_responses split is
- * per-model, so provider-level inference resolves OpenAI-compatible to `openai`.
+ * Resolves a catalog provider entry to a supported wire type. Honors an
+ * explicit `type`, otherwise infers from `npm`/`id`. Unknown providers return
+ * `undefined` so callers can omit them instead of writing an invalid config.
  */
-export function inferWireType(entry: CatalogProviderEntry): ProviderType {
+export function inferWireType(entry: CatalogProviderEntry): ProviderType | undefined {
   if (isWireType(entry.type)) return entry.type;
   const npm = (entry.npm ?? '').toLowerCase();
   const id = (entry.id ?? '').toLowerCase();
@@ -72,7 +89,8 @@ export function inferWireType(entry: CatalogProviderEntry): ProviderType {
   if (npm.includes('google') || id.includes('google') || id.includes('gemini')) {
     return 'google-genai';
   }
-  return 'openai';
+  if (npm.includes('openai') || id.includes('openai')) return 'openai';
+  return undefined;
 }
 
 /**
@@ -101,6 +119,7 @@ export function catalogModelToCapability(model: CatalogModelEntry): CatalogModel
   if (typeof model.id !== 'string' || model.id.length === 0) return undefined;
   const context = model.limit?.context;
   if (typeof context !== 'number' || !Number.isInteger(context) || context <= 0) return undefined;
+  if (!isUsableChatModel(model)) return undefined;
   const inputs = model.modalities?.input ?? [];
   const output = model.limit?.output;
   return {

packages/kosong/src/catalog.ts

@@ -22,9 +22,9 @@ describe('inferWireType', () => {
     expect(inferWireType({ id: 'google-vertex' })).toBe('vertexai');
   });
 
-  it('falls back to openai for unknown / invalid type', () => {
-    expect(inferWireType({ id: 'some-proxy' })).toBe('openai');
-    expect(inferWireType({ id: 'x', type: 'not-a-wire' })).toBe('openai');
+  it('returns undefined for unknown / invalid wire types', () => {
+    expect(inferWireType({ id: 'some-proxy' })).toBeUndefined();
+    expect(inferWireType({ id: 'x', type: 'not-a-wire' })).toBeUndefined();
   });
 });
 
@@ -92,6 +92,36 @@ describe('catalogModelToCapability', () => {
     expect(catalogModelToCapability({ id: 'm' })).toBeUndefined();
     expect(catalogModelToCapability({ id: 'm', limit: { context: 0 } })).toBeUndefined();
   });
+
+  it('skips embedding and non-text-output models that cannot serve as chat defaults', () => {
+    expect(
+      catalogModelToCapability({
+        id: 'text-embedding-3-large',
+        name: 'text-embedding-3-large',
+        family: 'text-embedding',
+        limit: { context: 8192, output: 1536 },
+        modalities: { input: ['text'], output: ['text'] },
+      }),
+    ).toBeUndefined();
+    expect(
+      catalogModelToCapability({
+        id: 'grok-imagine-image',
+        name: 'Grok Imagine Image',
+        family: 'grok',
+        limit: { context: 8000 },
+        modalities: { input: ['text', 'image'], output: ['image', 'pdf'] },
+      }),
+    ).toBeUndefined();
+    expect(
+      catalogModelToCapability({
+        id: 'mimo-v2-tts',
+        name: 'MiMo-V2-TTS',
+        family: 'mimo',
+        limit: { context: 8192, output: 16384 },
+        modalities: { input: ['text'], output: ['audio'] },
+      }),
+    ).toBeUndefined();
+  });
 });
 
 describe('catalogProviderModels', () => {

packages/kosong/test/catalog.test.ts

@@ -72,12 +72,6 @@ export interface ApplyCatalogProviderOptions {
   readonly thinking: boolean;
 }
 
-/**
- * Writes a catalog-selected provider and its model aliases into config,
- * replacing any stale aliases that belonged to the same provider. Model
- * metadata (context window, output limit, capabilities) comes from the
- * catalog, so the user does not hand-write it. Returns the default model key.
- */
 /**
  * Parses an optional pruned models.dev catalog string — typically the
  * `__KIMI_CODE_BUILT_IN_CATALOG__` constant injected by tsdown at build
@@ -92,6 +86,18 @@ export function loadBuiltInCatalog(text?: string): Catalog | undefined {
   }
 }
 
+/**
+ * Writes a catalog-selected provider and its model aliases into `config` and
+ * marks it the default. Model metadata (context, output limit, capabilities)
+ * comes from the catalog, so the user does not hand-write it. Returns the
+ * default model key.
+ *
+ * NOTE: the same-provider cleanup below mutates the passed-in `config` only.
+ * It clears stale aliases on disk solely when the caller overwrites the whole
+ * config. Callers persisting via `setConfig` — a deep-merge patch that cannot
+ * delete keys — must call `removeProvider` first, or removed aliases reappear
+ * after the merge.
+ */
 export function applyCatalogProvider(
   config: KimiConfig,
   options: ApplyCatalogProviderOptions,