feat: provider model list in desktop and fix bun run tauri dev can't keep

desktop/src/components/controls/ModelSelector.tsx

@@ -1,9 +1,8 @@
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
 import { createPortal } from 'react-dom'
-import { OFFICIAL_DEFAULT_MODEL_ID, OFFICIAL_MODELS } from '../../constants/modelCatalog'
+import { OFFICIAL_DEFAULT_MODEL_ID } from '../../constants/modelCatalog'
 import {
   OPENAI_OFFICIAL_DEFAULT_MODEL_ID,
-  OPENAI_OFFICIAL_MODELS,
   OPENAI_OFFICIAL_PROVIDER_ID,
 } from '../../constants/openaiOfficialProvider'
 import { useTranslation } from '../../i18n'
@@ -42,88 +41,59 @@ type DropdownPosition = {
   maxHeight: number
 }
 
+const CLI_PROVIDER_NAMES: Record<string, string> = {
+  nvidia: 'NVIDIA',
+  openrouter: 'OpenRouter',
+  opencode: 'OpenCode Zen',
+  local: 'Local',
+}
+
 const DROPDOWN_WIDTH = 360
 const DROPDOWN_GAP = 8
 const VIEWPORT_MARGIN = 16
 const DROPDOWN_MAX_HEIGHT = 420
 const DROPDOWN_MIN_HEIGHT = 180
 
-function officialChoices(
-  providerId: string | null,
-  models: ModelInfo[],
-  isDefault: boolean,
-  officialName: string,
-): ProviderChoice {
-  return {
-    providerId,
-    providerName: officialName,
-    isDefault,
-    models,
-  }
-}
+function buildProviderChoices(
+  providers: SavedProvider[],
+  availableModels: ModelInfo[],
+  activeProviderId: string | null,
+): ProviderChoice[] {
+  if (activeProviderId && availableModels.length > 0) {
+    const isCli = activeProviderId.startsWith('cli-')
+
+    if (isCli) {
+      const cliProviderKey = activeProviderId.replace('cli-', '')
+      const cliProviderName = CLI_PROVIDER_NAMES[cliProviderKey] || activeProviderId
+      return [{
+        providerId: activeProviderId,
+        providerName: cliProviderName,
+        isDefault: true,
+        models: availableModels,
+      }]
+    }
 
-function buildProviderModels(
-  provider: SavedProvider,
-  labels: Record<'main' | 'haiku' | 'sonnet' | 'opus', string>,
-): ModelInfo[] {
-  const entries: Array<{ id: string; label: string }> = [
-    { id: provider.models.main.trim(), label: labels.main },
-    { id: provider.models.haiku.trim(), label: labels.haiku },
-    { id: provider.models.sonnet.trim(), label: labels.sonnet },
-    { id: provider.models.opus.trim(), label: labels.opus },
-  ]
+    if (activeProviderId === OPENAI_OFFICIAL_PROVIDER_ID) {
+      return [{
+        providerId: OPENAI_OFFICIAL_PROVIDER_ID,
+        providerName: 'OpenAI',
+        isDefault: true,
+        models: availableModels,
+      }]
+    }
 
-  const byId = new Map<string, { id: string; labels: string[] }>()
-  for (const entry of entries) {
-    if (!entry.id) continue
-    const existing = byId.get(entry.id)
-    if (existing) {
-      if (!existing.labels.includes(entry.label)) {
-        existing.labels.push(entry.label)
-      }
-      continue
+    const provider = providers.find(p => p.id === activeProviderId)
+    if (provider) {
+      return [{
+        providerId: provider.id,
+        providerName: provider.name,
+        isDefault: true,
+        models: availableModels,
+      }]
     }
-    byId.set(entry.id, { id: entry.id, labels: [entry.label] })
   }
 
-  return [...byId.values()].map((entry) => ({
-    id: entry.id,
-    name: entry.id,
-    description: entry.labels.join(' · '),
-    context: '',
-  }))
-}
-
-function buildProviderChoices(
-  providers: SavedProvider[],
-  activeId: string | null,
-  availableModels: ModelInfo[],
-  officialName: string,
-  openAIOfficialName: string,
-  labels: Record<'main' | 'haiku' | 'sonnet' | 'opus', string>,
-): ProviderChoice[] {
-  const claudeOfficialModels = activeId === null && availableModels.length > 0
-    ? availableModels
-    : OFFICIAL_MODELS
-  const openAIOfficialModels = activeId === OPENAI_OFFICIAL_PROVIDER_ID && availableModels.length > 0
-    ? availableModels
-    : OPENAI_OFFICIAL_MODELS
-
-  return [
-    officialChoices(null, claudeOfficialModels, activeId === null, officialName),
-    officialChoices(
-      OPENAI_OFFICIAL_PROVIDER_ID,
-      openAIOfficialModels,
-      activeId === OPENAI_OFFICIAL_PROVIDER_ID,
-      openAIOfficialName,
-    ),
-    ...providers.map((provider) => ({
-      providerId: provider.id,
-      providerName: provider.name,
-      isDefault: activeId === provider.id,
-      models: buildProviderModels(provider, labels),
-    })),
-  ]
+  return []
 }
 
 function resolveDefaultRuntimeSelection(
@@ -163,6 +133,7 @@ export function ModelSelector({
     currentModel: storeModel,
     availableModels,
     effortLevel,
+    activeProviderId,
     activeProviderName,
     setModel,
     setEffort,
@@ -272,26 +243,13 @@ export function ModelSelector({
     }
   }, [open, updateDropdownPosition])
 
-  const roleLabels = useMemo(
-    () => ({
-      main: t('settings.providers.mainModel'),
-      haiku: t('settings.providers.haikuModel'),
-      sonnet: t('settings.providers.sonnetModel'),
-      opus: t('settings.providers.opusModel'),
-    }),
-    [t],
-  )
-
   const providerChoices = useMemo(
     () => buildProviderChoices(
       providers,
-      activeId,
       availableModels,
-      t('settings.providers.officialName'),
-      t('settings.providers.openaiOfficialName'),
-      roleLabels,
+      activeProviderId,
     ),
-    [activeId, availableModels, providers, roleLabels, t],
+    [activeProviderId, availableModels, providers],
   )
 
   const selectedModel = isControlled

desktop/src/stores/settingsStore.ts

@@ -53,6 +53,7 @@ type SettingsStore = {
   effortLevel: EffortLevel
   thinkingEnabled: boolean
   availableModels: ModelInfo[]
+  activeProviderId: string | null
   activeProviderName: string | null
   locale: Locale
   theme: ThemeMode
@@ -134,6 +135,7 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
   effortLevel: 'medium',
   thinkingEnabled: true,
   availableModels: [],
+  activeProviderId: null,
   activeProviderName: null,
   locale: getStoredLocale(),
   theme: useUIStore.getState().theme,
@@ -181,6 +183,7 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
       set({
         permissionMode: mode,
         availableModels: modelsRes.models,
+        activeProviderId: modelsRes.provider?.id ?? null,
         activeProviderName: modelsRes.provider?.name ?? null,
         currentModel: model,
         effortLevel: level,

src/server/api/models.ts

@@ -247,6 +247,32 @@ async function fetchCliProviderModels(): Promise<ApiModelInfo[]> {
         // fall through
       }
     }
+
+    // ── NVIDIA NIM ────────────────────────────────────────────
+    if (authProvider === 'nvidia' && config.nvidiaApiKey) {
+      try {
+        const res = await fetch('https://integrate.api.nvidia.com/v1/models', {
+          headers: { Authorization: `Bearer ${config.nvidiaApiKey}` },
+        })
+        if (res.ok) {
+          const data = await res.json() as any
+          const models: ApiModelInfo[] = (data.data || []).map((m: any) => ({
+            id: m.id,
+            name: m.id,
+            description: m.owned_by || '',
+            context: '',
+          }))
+
+          if (models.length > 0) {
+            cliProviderModelCache = models
+            cliProviderModelCacheTime = Date.now()
+            return models
+          }
+        }
+      } catch {
+        // fall through
+      }
+    }
   } catch {
     // fall through
   }
@@ -314,53 +340,49 @@ const CLI_PROVIDER_NAMES: Record<string, string> = {
 }
 
 async function handleModelsList(): Promise<Response> {
-  // First check if CLI has an authProvider configured — this takes precedence
-  // over cc-haha providers since CLI's /login command manages it
   const cliConfig = await readCliAuthProvider()
   const cliAuthProvider = cliConfig?.authProvider
 
-  if (cliAuthProvider && cliAuthProvider !== 'anthropic' && cliAuthProvider !== 'openai') {
-    const cliModels = await fetchCliProviderModels()
-    if (cliModels.length > 0) {
+  const { providers, activeId } = await providerService.listProviders()
+
+  if (activeId) {
+    const activeProvider = providers.find((p) => p.id === activeId)
+    if (activeProvider) {
+      if (activeProvider.presetId === 'tui-nvidia' && cliAuthProvider === 'nvidia') {
+        const cliModels = await fetchCliProviderModels()
+        if (cliModels.length > 0) {
+          return Response.json({
+            models: cliModels,
+            provider: { id: activeProvider.id, name: activeProvider.name },
+          })
+        }
+      }
+
+      if (isOpenAIOfficialProviderId(activeId)) {
+        return Response.json({
+          models: buildOpenAIModelList(),
+          provider: { id: OPENAI_OFFICIAL_PROVIDER_ID, name: OPENAI_OFFICIAL_PROVIDER_NAME },
+        })
+      }
+
       return Response.json({
-        models: cliModels,
-        provider: {
-          id: `cli-${cliAuthProvider}`,
-          name: CLI_PROVIDER_NAMES[cliAuthProvider] || cliAuthProvider,
-        },
+        models: buildProviderModelList(activeProvider.models),
+        provider: { id: activeProvider.id, name: activeProvider.name },
       })
     }
-    // If no models fetched yet but authProvider is set, still return provider info
-    // The model list will be populated once available
-    return Response.json({
-      models: [],
-      provider: {
-        id: `cli-${cliAuthProvider}`,
-        name: CLI_PROVIDER_NAMES[cliAuthProvider] || cliAuthProvider,
-      },
-    })
   }
 
-  const { providers, activeId } = await providerService.listProviders()
-  if (isOpenAIOfficialProviderId(activeId)) {
+  if (cliAuthProvider && cliAuthProvider !== 'anthropic' && cliAuthProvider !== 'openai') {
+    const cliModels = await fetchCliProviderModels()
     return Response.json({
-      models: buildOpenAIModelList(),
+      models: cliModels,
       provider: {
-        id: OPENAI_OFFICIAL_PROVIDER_ID,
-        name: OPENAI_OFFICIAL_PROVIDER_NAME,
+        id: `cli-${cliAuthProvider}`,
+        name: CLI_PROVIDER_NAMES[cliAuthProvider] || cliAuthProvider,
       },
     })
   }
 
-  const activeProvider = activeId ? providers.find((p) => p.id === activeId) : null
-  if (activeProvider) {
-    const modelList = buildProviderModelList(activeProvider.models)
-    return Response.json({
-      models: modelList,
-      provider: { id: activeProvider.id, name: activeProvider.name },
-    })
-  }
-
   return Response.json({ models: getStandaloneModelList(), provider: null })
 }