fix: sync settingsStore when cliAuthStore saves provider config

desktop: fix provider switch model selector real-time update

When switching providers via CliLoginProviderSettings login panels
(NVIDIA, OpenRouter, OpenAI, OpenCode, Local), the settingsStore's
activeProviderId/activeProviderName were never updated, causing the
conversation model's provider badge to stay stale until a full app
restart.

Fixes:
- cliAuthStore: call settingsStore.syncFromConfig() after every save
(saveNvidiaApiKey, saveOpenRouterApiKey, saveOpenAIApiKey,
saveOpenCodeApiKey, saveLocalModelConfig, setAuthProvider,
clearAuth)
- settingsStore: add syncFromConfig() action that re-reads
~/.claude.json and syncs activeProviderId/activeProviderName
- settingsStore: add setActiveProvider() for optimistic UI updates
- settingsStore.fetchAll(): fallback to deriving provider info from
config.authProvider when both direct API fetch and sidecar fail
- ModelSelector: add fallback path when availableModels is empty
(local provider, fetch failures) so it builds choices from the
saved provider list
- providerStore: add clearProviderModelCache() call on provider switch
- providerStore: remove duplicate activateOfficial definition
- providerStore: call settingsStore.setActiveProvider() immediately
(optimistic) before writing to config file

desktop/src/api/providerModels.ts

@@ -27,6 +27,10 @@ const CACHE_TTL = 5 * 60 * 1000 // 5 minutes
 export function clearProviderModelCache(): void {
   modelCache = null
   cacheTime = 0
+  orCache = null
+  orCacheTime = 0
+  nvCache = null
+  nvCacheTime = 0
 }
 
 // ─── Main entry ──────────────────────────────────────────────────────────────

desktop/src/components/controls/ModelSelector.tsx

@@ -45,7 +45,9 @@ const CLI_PROVIDER_NAMES: Record<string, string> = {
   nvidia: 'NVIDIA',
   openrouter: 'OpenRouter',
   opencode: 'OpenCode Zen',
+  openai: 'OpenAI',
   local: 'Local',
+  anthropic: 'Anthropic',
 }
 
 const DROPDOWN_WIDTH = 360
@@ -59,7 +61,10 @@ function buildProviderChoices(
   availableModels: ModelInfo[],
   activeProviderId: string | null,
 ): ProviderChoice[] {
-  if (activeProviderId && availableModels.length > 0) {
+  if (!activeProviderId) return []
+
+  // First try: if we have availableModels from fetchProviderModels, use them
+  if (availableModels.length > 0) {
     const isCli = activeProviderId.startsWith('cli-')
 
     if (isCli) {
@@ -93,6 +98,48 @@ function buildProviderChoices(
     }
   }
 
+  // Fallback: if availableModels is empty (e.g. local provider, or fetch failed),
+  // build choices from the saved providers list
+  const isCli = activeProviderId.startsWith('cli-')
+  if (isCli) {
+    const cliProviderKey = activeProviderId.replace('cli-', '')
+    const cliProviderName = CLI_PROVIDER_NAMES[cliProviderKey] || activeProviderId
+    const provider = providers.find(p => p.id === activeProviderId)
+    const models = provider
+      ? Object.values(provider.models).filter(Boolean).map(id => ({
+          id,
+          name: id,
+          description: '',
+          context: '',
+        }))
+      : []
+    return [{
+      providerId: activeProviderId,
+      providerName: cliProviderName,
+      isDefault: true,
+      models,
+    }]
+  }
+
+  if (activeProviderId === OPENAI_OFFICIAL_PROVIDER_ID) {
+    return [{
+      providerId: OPENAI_OFFICIAL_PROVIDER_ID,
+      providerName: 'OpenAI',
+      isDefault: true,
+      models: availableModels,
+    }]
+  }
+
+  const provider = providers.find(p => p.id === activeProviderId)
+  if (provider) {
+    return [{
+      providerId: provider.id,
+      providerName: provider.name,
+      isDefault: true,
+      models: availableModels,
+    }]
+  }
+
   return []
 }
 

desktop/src/lib/tuiConversation.ts

@@ -184,12 +184,22 @@ async function* streamOpenAI(
   const decoder = new TextDecoder()
   const reader = res.body.getReader()
   let buffer = ''
+  let hasReceivedContent = false
+  const IDLE_TIMEOUT_MS = 3000
 
   yield { type: 'content_block_start', index: 0, blockType: 'text' }
 
   while (true) {
     if (signal?.aborted) break
-    const { done, value } = await reader.read()
+
+    // Race between read and idle timeout.  Some local providers (Ollama, LM Studio,
+    // etc.) never send [DONE] or close the SSE connection after the response is
+    // complete.  The timeout lets us detect this and finish cleanly.
+    const readPromise = reader.read()
+    const timeoutPromise = new Promise<{ done: true; value: undefined }>((resolve) =>
+      setTimeout(() => resolve({ done: true, value: undefined }), IDLE_TIMEOUT_MS),
+    )
+    const { done, value } = await Promise.race([readPromise, timeoutPromise])
     if (done) break
 
     buffer += decoder.decode(value, { stream: true })
@@ -201,6 +211,7 @@ async function* streamOpenAI(
       const raw = line.slice(6).trim()
       if (raw === '[DONE]') {
         yield { type: 'content_block_stop', index: 0 }
+        yield { type: 'message_stop' }
         yield { type: 'done' }
         return
       }

desktop/src/stores/cliAuthStore.ts

@@ -6,6 +6,7 @@
  */
 import { create } from 'zustand'
 import { getTuiConfig, saveTuiConfigPatch, clearConfigCache } from '../api/config'
+import { useSettingsStore } from './settingsStore'
 
 type AuthProvider = 'anthropic' | 'openai' | 'openrouter' | 'local' | 'opencode' | 'nvidia'
 
@@ -71,6 +72,7 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
     try {
       await saveTuiConfigPatch({ authProvider: provider })
       clearConfigCache()
+      await useSettingsStore.getState().syncFromConfig()
       set({ authProvider: provider, isLoading: false })
     } catch (err) {
       set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
@@ -85,6 +87,7 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
         nvidiaApiKey: apiKey,
       })
       clearConfigCache()
+      await useSettingsStore.getState().syncFromConfig()
       set({ authProvider: 'nvidia', nvidiaApiKey: apiKey, isLoading: false })
     } catch (err) {
       set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
@@ -99,6 +102,7 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
         openRouterApiKey: apiKey,
       })
       clearConfigCache()
+      await useSettingsStore.getState().syncFromConfig()
       set({ authProvider: 'openrouter', openRouterApiKey: apiKey, isLoading: false })
     } catch (err) {
       set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
@@ -114,6 +118,7 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
         openAiAccessToken: undefined, // Clear OAuth token when switching to API key
       })
       clearConfigCache()
+      await useSettingsStore.getState().syncFromConfig()
       set({ authProvider: 'openai', openAiApiKey: apiKey, isLoading: false })
     } catch (err) {
       set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
@@ -129,6 +134,7 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
         openCodeModelName: modelName || undefined,
       })
       clearConfigCache()
+      await useSettingsStore.getState().syncFromConfig()
       set({
         authProvider: 'opencode',
         openCodeApiKey: apiKey,
@@ -149,6 +155,7 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
         localModelName: modelName,
       })
       clearConfigCache()
+      await useSettingsStore.getState().syncFromConfig()
       set({
         authProvider: 'local',
         localBaseUrl: baseUrl,
@@ -177,6 +184,7 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
         localModelName: undefined,
       })
       clearConfigCache()
+      await useSettingsStore.getState().syncFromConfig()
       set({
         authProvider: null,
         nvidiaApiKey: null,

desktop/src/stores/providerStore.ts

@@ -11,6 +11,7 @@ import {
   OPENAI_OFFICIAL_PROVIDER_ID,
 } from '../constants/openaiOfficialProvider'
 import { saveTuiConfigPatch, clearConfigCache } from '../api/config'
+import { clearProviderModelCache } from '../api/providerModels'
 import type {
   SavedProvider,
   CreateProviderInput,
@@ -53,13 +54,27 @@ function providerModelIds(provider: SavedProvider): Set<string> {
 type TuiProviderMapping = { authProvider: string; apiKeyField: string; apiKey?: string } | null
 function mapSidecarToTuiProvider(provider: SavedProvider): TuiProviderMapping {
   const apiFormat = provider.apiFormat || 'anthropic'
+  const baseUrl = (provider.baseUrl || '').toLowerCase()
+  const name = (provider.name || '').toLowerCase()
+
+  // Detect local provider (Ollama, LM Studio, vLLM, etc.)
+  if (
+    apiFormat === 'openai' &&
+    (baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1') || baseUrl.includes('0.0.0.0') ||
+     name.includes('local') || name.includes('ollama'))
+  ) {
+    return {
+      authProvider: 'local',
+      apiKeyField: 'localBaseUrl',
+      // TUI's local config expects localBaseUrl + localModelName
+      apiKey: provider.baseUrl,
+    }
+  }
+
   switch (apiFormat) {
     case 'anthropic':
       return { authProvider: 'anthropic', apiKeyField: 'anthropicApiKey', apiKey: provider.apiKey }
     case 'openai': {
-      // Try to infer specific provider from base URL or name
-      const baseUrl = (provider.baseUrl || '').toLowerCase()
-      const name = (provider.name || '').toLowerCase()
       if (baseUrl.includes('nvidia') || name.includes('nvidia')) {
         return { authProvider: 'nvidia', apiKeyField: 'nvidiaApiKey', apiKey: provider.apiKey }
       }
@@ -176,28 +191,44 @@ export const useProviderStore = create<ProviderStore>((set, get) => ({
   activateProvider: async (id) => {
     await providersApi.activate(id)
     await get().fetchProviders()
-    // 同步 provider 信息到 ~/.claude.json，这样 fetchProviderModels() / tuiConversation
-    // 可以直接通过 TUI 方式来读取配置，无需依赖 sidecar。
-    const settings = useSettingsStore.getState()
-    if (id === OPENAI_OFFICIAL_PROVIDER_ID) {
-      await saveTuiConfigPatch({ authProvider: 'anthropic' })
-      await settings.setModel(OPENAI_OFFICIAL_DEFAULT_MODEL_ID)
-      await settings.fetchAll()
-      return
-    }
 
     const provider = get().providers.find((p) => p.id === id)
     if (!provider) return
 
-    // Map sidecar apiFormat to TUI authProvider
+    // Derive CLI authProvider from the sidecar provider
     const tuiProvider = mapSidecarToTuiProvider(provider)
+    const authProvider = tuiProvider?.authProvider ?? null
+    const cliProviderId = authProvider ? `cli-${authProvider}` : null
+    const CLI_PROVIDER_NAMES: Record<string, string> = {
+      nvidia: 'NVIDIA',
+      openrouter: 'OpenRouter',
+      opencode: 'OpenCode Zen',
+      openai: 'OpenAI',
+      local: 'Local',
+      anthropic: 'Anthropic',
+    }
+    const cliProviderName = authProvider ? (CLI_PROVIDER_NAMES[authProvider] ?? authProvider) : null
+
+    // Optimistically update settingsStore so the UI reflects the change immediately
+    const settings = useSettingsStore.getState()
+    const cliModels = Object.values(provider.models).filter(Boolean).map(id => ({
+      id, name: id, description: '', context: '',
+    }))
+    settings.setActiveProvider(cliProviderId, cliProviderName, cliModels)
+
+    // Sync provider info to ~/.claude.json
     const patch: Record<string, unknown> = {}
-    if (tuiProvider) {
-      patch.authProvider = tuiProvider.authProvider
-      if (tuiProvider.apiKey) patch[tuiProvider.apiKeyField] = tuiProvider.apiKey
+    if (authProvider) patch.authProvider = authProvider
+    if (tuiProvider?.authProvider === 'local') {
+      patch.localBaseUrl = provider.baseUrl
+      patch.localModelName = provider.models.main
+    } else if (tuiProvider?.apiKey) {
+      patch[tuiProvider.apiKeyField] = tuiProvider.apiKey
     }
     patch.model = provider.models.main
+
     await saveTuiConfigPatch(patch)
+    clearProviderModelCache()
     clearConfigCache()
 
     await settings.setModel(provider.models.main)
@@ -209,21 +240,13 @@ export const useProviderStore = create<ProviderStore>((set, get) => ({
     await get().fetchProviders()
     // 同步回 Anthropic first-party
     await saveTuiConfigPatch({ authProvider: 'anthropic' })
+    clearProviderModelCache()
     clearConfigCache()
     const settings = useSettingsStore.getState()
     await settings.setModel(OFFICIAL_DEFAULT_MODEL_ID)
     await settings.fetchAll()
   },
 
-  activateOfficial: async () => {
-    await providersApi.activateOfficial()
-    await get().fetchProviders()
-    // 切回官方默认时同样重置 currentModel，避免残留第三方 model id。
-    const settings = useSettingsStore.getState()
-    await settings.setModel(OFFICIAL_DEFAULT_MODEL_ID)
-    await settings.fetchAll()
-  },
-
   testProvider: async (id, overrides?) => {
     const { result } = await providersApi.test(id, overrides)
     return result

desktop/src/stores/settingsStore.ts

@@ -1,10 +1,9 @@
 import { create } from 'zustand'
 import { ApiError } from '../api/client'
 import { settingsApi } from '../api/settings'
-import { modelsApi } from '../api/models'
 import { h5AccessApi } from '../api/h5Access'
-import { fetchProviderModels } from '../api/providerModels'
-import { getTuiConfig, saveTuiConfigPatch } from '../api/config'
+import { fetchProviderModels, clearProviderModelCache } from '../api/providerModels'
+import { getTuiConfig, saveTuiConfigPatch, clearConfigCache } from '../api/config'
 import {
   isThemeMode,
   type AppMode,
@@ -79,6 +78,8 @@ type SettingsStore = {
   fetchH5Access: () => Promise<void>
   setPermissionMode: (mode: PermissionMode) => Promise<void>
   setModel: (modelId: string) => Promise<void>
+  setActiveProvider: (providerId: string | null, providerName: string | null, models: ModelInfo[]) => void
+  syncFromConfig: () => Promise<void>
   setEffort: (level: EffortLevel) => Promise<void>
   setThinkingEnabled: (enabled: boolean) => Promise<void>
   setLocale: (locale: Locale) => void
@@ -192,11 +193,22 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
         activeProviderId = directModels.provider?.id ?? null
         activeProviderName = directModels.provider?.name ?? null
       } else {
-        const sidecarRes = await modelsApi.list().catch(() => null)
-        if (sidecarRes && sidecarRes.models.length > 0) {
-          availableModels = sidecarRes.models
-          activeProviderId = sidecarRes.provider?.id ?? null
-          activeProviderName = sidecarRes.provider?.name ?? null
+        // No direct models — always derive from ~/.claude.json authProvider.
+        // Never use sidecar's provider name: it may be stale and corrupted
+        // (e.g. "TUI: NVIDIA NIM" instead of "NVIDIA").
+        const authProvider = config.authProvider as string | undefined
+        if (authProvider) {
+          const CLI_PROVIDER_NAMES: Record<string, string> = {
+            nvidia: 'NVIDIA',
+            openrouter: 'OpenRouter',
+            opencode: 'OpenCode Zen',
+            openai: 'OpenAI',
+            local: 'Local',
+            anthropic: 'Anthropic',
+          }
+          availableModels = []
+          activeProviderId = `cli-${authProvider}`
+          activeProviderName = CLI_PROVIDER_NAMES[authProvider] ?? authProvider
         } else {
           availableModels = []
           activeProviderId = null
@@ -275,6 +287,49 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
     set({ currentModel })
   },
 
+  setActiveProvider: (providerId, providerName, models) => {
+    set({
+      activeProviderId: providerId,
+      activeProviderName: providerName,
+      availableModels: models,
+      currentModel: models.length > 0
+        ? models[0]
+        : null,
+    })
+  },
+
+  syncFromConfig: async () => {
+    // Re-read ~/.claude.json and re-fetch the model list for the new provider.
+    // This keeps settingsStore in sync when cliAuthStore writes to the config file.
+    clearProviderModelCache()
+    clearConfigCache()
+    const config = await getTuiConfig().catch(() => ({}))
+    const authProvider = config?.authProvider as string | undefined
+    if (!authProvider) {
+      set({ activeProviderId: null, activeProviderName: null, availableModels: [], currentModel: null })
+      return
+    }
+    const CLI_NAMES: Record<string, string> = {
+      nvidia: 'NVIDIA',
+      openrouter: 'OpenRouter',
+      opencode: 'OpenCode Zen',
+      openai: 'OpenAI',
+      local: 'Local',
+      anthropic: 'Anthropic',
+    }
+    const cliProviderId = `cli-${authProvider}`
+    const cliProviderName = CLI_NAMES[authProvider] ?? authProvider
+
+    // Fetch fresh models for the new provider
+    const { models } = await fetchProviderModels().catch(() => ({ models: [] as ModelInfo[], provider: null }))
+    set({
+      activeProviderId: cliProviderId,
+      activeProviderName: cliProviderName,
+      availableModels: models,
+      currentModel: models.length > 0 ? models[0] : null,
+    })
+  },
+
   setEffort: async (level) => {
     const prev = get().effortLevel
     set({ effortLevel: level })