@lobehub/chat 0.161.8 → 0.161.10

package/src/store/user/slices/modelList/action.test.ts

@@ -0,0 +1,363 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { modelsService } from '@/services/models';
+import { userService } from '@/services/user';
+import { useUserStore } from '@/store/user';
+import { GeneralModelProviderConfig } from '@/types/settings';
+
+import { settingsSelectors } from '../settings/selectors';
+import { CustomModelCardDispatch } from './reducers/customModelCard';
+import { modelProviderSelectors } from './selectors';
+
+// Mock userService
+vi.mock('@/services/user', () => ({
+  userService: {
+    updateUserSettings: vi.fn(),
+    resetUserSettings: vi.fn(),
+  },
+}));
+
+vi.mock('zustand/traditional');
+
+describe('LLMSettingsSliceAction', () => {
+  describe('setModelProviderConfig', () => {
+    it('should set OpenAI configuration', async () => {
+      const { result } = renderHook(() => useUserStore());
+      const openAIConfig: Partial<GeneralModelProviderConfig> = { apiKey: 'test-key' };
+
+      // Perform the action
+      await act(async () => {
+        await result.current.setModelProviderConfig('openai', openAIConfig);
+      });
+
+      // Assert that updateUserSettings was called with the correct OpenAI configuration
+      expect(userService.updateUserSettings).toHaveBeenCalledWith({
+        languageModel: {
+          openai: openAIConfig,
+        },
+      });
+    });
+  });
+
+  describe('dispatchCustomModelCards', () => {
+    it('should return early when prevState does not exist', async () => {
+      const { result } = renderHook(() => useUserStore());
+      const provider = 'openai';
+      const payload: CustomModelCardDispatch = { type: 'add', modelCard: { id: 'test-id' } };
+
+      // Mock the selector to return undefined
+      vi.spyOn(settingsSelectors, 'providerConfig').mockReturnValueOnce(() => undefined);
+      vi.spyOn(result.current, 'setModelProviderConfig');
+
+      await act(async () => {
+        await result.current.dispatchCustomModelCards(provider, payload);
+      });
+
+      // Assert that setModelProviderConfig was not called
+      expect(result.current.setModelProviderConfig).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('refreshDefaultModelProviderList', () => {
+    it('default', async () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          serverLanguageModel: {
+            azure: { serverModelCards: [{ id: 'abc', deploymentName: 'abc' }] },
+          },
+        });
+      });
+
+      act(() => {
+        result.current.refreshDefaultModelProviderList();
+      });
+
+      // Assert that setModelProviderConfig was not called
+      const azure = result.current.defaultModelProviderList.find((m) => m.id === 'azure');
+      expect(azure?.chatModels).toEqual([{ id: 'abc', deploymentName: 'abc' }]);
+    });
+
+    it('openai', () => {
+      const { result } = renderHook(() => useUserStore());
+      act(() => {
+        useUserStore.setState({
+          serverLanguageModel: {
+            openai: {
+              enabled: true,
+              enabledModels: ['gpt-4-0125-preview', 'gpt-4-turbo-2024-04-09'],
+              serverModelCards: [
+                {
+                  displayName: 'ChatGPT-4',
+                  functionCall: true,
+                  id: 'gpt-4-0125-preview',
+                  tokens: 128000,
+                  enabled: true,
+                },
+                {
+                  displayName: 'ChatGPT-4 Vision',
+                  functionCall: true,
+                  id: 'gpt-4-turbo-2024-04-09',
+                  tokens: 128000,
+                  vision: true,
+                  enabled: true,
+                },
+              ],
+            },
+          },
+        });
+      });
+
+      act(() => {
+        result.current.refreshDefaultModelProviderList();
+      });
+
+      // Assert that setModelProviderConfig was not called
+      const openai = result.current.defaultModelProviderList.find((m) => m.id === 'openai');
+      expect(openai?.chatModels).toEqual([
+        {
+          displayName: 'ChatGPT-4',
+          enabled: true,
+          functionCall: true,
+          id: 'gpt-4-0125-preview',
+          tokens: 128000,
+        },
+        {
+          displayName: 'ChatGPT-4 Vision',
+          enabled: true,
+          functionCall: true,
+          id: 'gpt-4-turbo-2024-04-09',
+          tokens: 128000,
+          vision: true,
+        },
+      ]);
+    });
+  });
+
+  describe('refreshModelProviderList', () => {
+    it('visible', async () => {
+      const { result } = renderHook(() => useUserStore());
+      act(() => {
+        useUserStore.setState({
+          settings: {
+            languageModel: {
+              ollama: { enabledModels: ['llava'] },
+            },
+          },
+        });
+      });
+
+      act(() => {
+        result.current.refreshModelProviderList();
+      });
+
+      const ollamaList = result.current.modelProviderList.find((r) => r.id === 'ollama');
+      // Assert that setModelProviderConfig was not called
+      expect(ollamaList?.chatModels.find((c) => c.id === 'llava')).toEqual({
+        displayName: 'LLaVA 7B',
+        enabled: true,
+        id: 'llava',
+        tokens: 4096,
+        vision: true,
+      });
+    });
+
+    it('modelProviderListForModelSelect should return only enabled providers', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        useUserStore.setState({
+          settings: {
+            languageModel: {
+              perplexity: { enabled: true },
+              azure: { enabled: false },
+            },
+          },
+        });
+      });
+
+      act(() => {
+        result.current.refreshModelProviderList();
+      });
+
+      const enabledProviders = modelProviderSelectors.modelProviderListForModelSelect(
+        result.current,
+      );
+      expect(enabledProviders).toHaveLength(3);
+      expect(enabledProviders.at(-1)!.id).toBe('perplexity');
+    });
+  });
+
+  describe('removeEnabledModels', () => {
+    it('should remove the specified model from enabledModels', async () => {
+      const { result } = renderHook(() => useUserStore());
+      const model = 'gpt-3.5-turbo';
+
+      const spyOn = vi.spyOn(userService, 'updateUserSettings');
+
+      act(() => {
+        useUserStore.setState({
+          settings: {
+            languageModel: {
+              azure: { enabledModels: ['gpt-3.5-turbo', 'gpt-4'] },
+            },
+          },
+        });
+      });
+
+      await act(async () => {
+        console.log(JSON.stringify(result.current.settings));
+        await result.current.removeEnabledModels('azure', model);
+      });
+
+      expect(spyOn).toHaveBeenCalledWith({
+        languageModel: {
+          azure: { enabledModels: ['gpt-4'] },
+        },
+      });
+    });
+  });
+
+  describe('toggleEditingCustomModelCard', () => {
+    it('should update editingCustomCardModel when params are provided', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        result.current.toggleEditingCustomModelCard({ id: 'test-id', provider: 'openai' });
+      });
+
+      expect(result.current.editingCustomCardModel).toEqual({ id: 'test-id', provider: 'openai' });
+    });
+
+    it('should reset editingCustomCardModel when no params are provided', () => {
+      const { result } = renderHook(() => useUserStore());
+
+      act(() => {
+        result.current.toggleEditingCustomModelCard();
+      });
+
+      expect(result.current.editingCustomCardModel).toBeUndefined();
+    });
+  });
+
+  describe('toggleProviderEnabled', () => {
+    it('should enable the provider', async () => {
+      const { result } = renderHook(() => useUserStore());
+
+      await act(async () => {
+        await result.current.toggleProviderEnabled('minimax', true);
+      });
+
+      expect(userService.updateUserSettings).toHaveBeenCalledWith({
+        languageModel: {
+          minimax: { enabled: true },
+        },
+      });
+    });
+
+    it('should disable the provider', async () => {
+      const { result } = renderHook(() => useUserStore());
+      const provider = 'openai';
+
+      await act(async () => {
+        await result.current.toggleProviderEnabled(provider, false);
+      });
+
+      expect(userService.updateUserSettings).toHaveBeenCalledWith({
+        languageModel: {
+          openai: { enabled: false },
+        },
+      });
+    });
+  });
+
+  describe('updateEnabledModels', () => {
+    // TODO: 有待 updateEnabledModels 实现的同步改造
+    it('should add new custom model to customModelCards', async () => {
+      const { result } = renderHook(() => useUserStore());
+      const provider = 'openai';
+      const modelKeys = ['gpt-3.5-turbo', 'custom-model'];
+      const options = [{ value: 'gpt-3.5-turbo' }, {}];
+
+      await act(async () => {
+        await result.current.updateEnabledModels(provider, modelKeys, options);
+      });
+
+      expect(userService.updateUserSettings).toHaveBeenCalledWith({
+        languageModel: {
+          openai: {
+            customModelCards: [{ id: 'custom-model' }],
+            // TODO：目标单测中需要包含下面这一行
+            // enabledModels: ['gpt-3.5-turbo', 'custom-model'],
+          },
+        },
+      });
+    });
+
+    it('should not add removed model to customModelCards', async () => {
+      const { result } = renderHook(() => useUserStore());
+      const provider = 'openai';
+      const modelKeys = ['gpt-3.5-turbo'];
+      const options = [{ value: 'gpt-3.5-turbo' }];
+
+      act(() => {
+        useUserStore.setState({
+          settings: {
+            languageModel: {
+              openai: { enabledModels: ['gpt-3.5-turbo', 'gpt-4'] },
+            },
+          },
+        });
+      });
+
+      await act(async () => {
+        await result.current.updateEnabledModels(provider, modelKeys, options);
+      });
+
+      expect(userService.updateUserSettings).toHaveBeenCalledWith({
+        languageModel: {
+          openai: { enabledModels: ['gpt-3.5-turbo'] },
+        },
+      });
+    });
+  });
+
+  describe('useFetchProviderModelList', () => {
+    it('should fetch data when enabledAutoFetch is true', async () => {
+      const { result } = renderHook(() => useUserStore());
+      const provider = 'openai';
+      const enabledAutoFetch = true;
+
+      const spyOn = vi.spyOn(result.current, 'refreshDefaultModelProviderList');
+
+      vi.spyOn(modelsService, 'getChatModels').mockResolvedValueOnce([]);
+
+      renderHook(() => result.current.useFetchProviderModelList(provider, enabledAutoFetch));
+
+      await waitFor(() => {
+        expect(spyOn).toHaveBeenCalled();
+      });
+
+      // expect(result.current.settings.languageModel.openai?.latestFetchTime).toBeDefined();
+      // expect(result.current.settings.languageModel.openai?.remoteModelCards).toBeDefined();
+    });
+
+    it('should not fetch data when enabledAutoFetch is false', async () => {
+      const { result } = renderHook(() => useUserStore());
+      const provider = 'openai';
+      const enabledAutoFetch = false;
+
+      const spyOn = vi.spyOn(result.current, 'refreshDefaultModelProviderList');
+
+      vi.spyOn(modelsService, 'getChatModels').mockResolvedValueOnce([]);
+
+      renderHook(() => result.current.useFetchProviderModelList(provider, enabledAutoFetch));
+
+      await waitFor(() => {
+        expect(spyOn).not.toHaveBeenCalled();
+      });
+    });
+  });
+});

package/src/store/user/slices/{settings/actions/llm.ts → modelList/action.ts}

@@ -1,39 +1,21 @@
+import { produce } from 'immer';
 import useSWR, { SWRResponse } from 'swr';
 import type { StateCreator } from 'zustand/vanilla';
 
-import {
-  AnthropicProviderCard,
-  AzureProviderCard,
-  BedrockProviderCard,
-  DeepSeekProviderCard,
-  GoogleProviderCard,
-  GroqProviderCard,
-  MinimaxProviderCard,
-  MistralProviderCard,
-  MoonshotProviderCard,
-  OllamaProviderCard,
-  OpenAIProviderCard,
-  OpenRouterProviderCard,
-  PerplexityProviderCard,
-  TogetherAIProviderCard,
-  ZeroOneProviderCard,
-  ZhiPuProviderCard,
-} from '@/config/modelProviders';
+import { DEFAULT_MODEL_PROVIDER_LIST } from '@/config/modelProviders';
+import { ModelProvider } from '@/libs/agent-runtime';
 import { UserStore } from '@/store/user';
 import { ChatModelCard } from '@/types/llm';
 import { GlobalLLMConfig, GlobalLLMProviderKey } from '@/types/settings';
-import { setNamespace } from '@/utils/storeDebug';
 
-import { CustomModelCardDispatch, customModelCardsReducer } from '../reducers/customModelCard';
-import { modelProviderSelectors } from '../selectors/modelProvider';
-import { settingsSelectors } from '../selectors/settings';
-
-const n = setNamespace('settings');
+import { settingsSelectors } from '../settings/selectors';
+import { CustomModelCardDispatch, customModelCardsReducer } from './reducers/customModelCard';
+import { modelProviderSelectors } from './selectors/modelProvider';
 
 /**
  * 设置操作
  */
-export interface LLMSettingsAction {
+export interface ModelListAction {
   dispatchCustomModelCards: (
     provider: GlobalLLMProviderKey,
     payload: CustomModelCardDispatch,
@@ -48,21 +30,28 @@ export interface LLMSettingsAction {
     provider: T,
     config: Partial<GlobalLLMConfig[T]>,
   ) => Promise<void>;
+
   toggleEditingCustomModelCard: (params?: { id: string; provider: GlobalLLMProviderKey }) => void;
 
   toggleProviderEnabled: (provider: GlobalLLMProviderKey, enabled: boolean) => Promise<void>;
 
+  updateEnabledModels: (
+    provider: GlobalLLMProviderKey,
+    modelKeys: string[],
+    options: { label?: string; value?: string }[],
+  ) => Promise<void>;
+
   useFetchProviderModelList: (
     provider: GlobalLLMProviderKey,
     enabledAutoFetch: boolean,
   ) => SWRResponse;
 }
 
-export const llmSettingsSlice: StateCreator<
+export const createModelListSlice: StateCreator<
   UserStore,
   [['zustand/devtools', never]],
   [],
-  LLMSettingsAction
+  ModelListAction
 > = (set, get) => ({
   dispatchCustomModelCards: async (provider, payload) => {
     const prevState = settingsSelectors.providerConfig(provider)(get());
@@ -73,7 +62,6 @@ export const llmSettingsSlice: StateCreator<
 
     await get().setModelProviderConfig(provider, { customModelCards: nextState });
   },
-
   refreshDefaultModelProviderList: (params) => {
     /**
      * Because we have several model cards sources, we need to merge the model cards
@@ -92,39 +80,27 @@ export const llmSettingsSlice: StateCreator<
       return serverChatModels ?? remoteChatModels ?? defaultChatModels;
     };
 
-    const defaultModelProviderList = [
-      {
-        ...OpenAIProviderCard,
-        chatModels: mergeModels('openai', OpenAIProviderCard.chatModels),
-      },
-      { ...AzureProviderCard, chatModels: mergeModels('azure', []) },
-      { ...OllamaProviderCard, chatModels: mergeModels('ollama', OllamaProviderCard.chatModels) },
-      AnthropicProviderCard,
-      GoogleProviderCard,
-      {
-        ...OpenRouterProviderCard,
-        chatModels: mergeModels('openrouter', OpenRouterProviderCard.chatModels),
-      },
-      {
-        ...TogetherAIProviderCard,
-        chatModels: mergeModels('togetherai', TogetherAIProviderCard.chatModels),
-      },
-      BedrockProviderCard,
-      DeepSeekProviderCard,
-      PerplexityProviderCard,
-      MinimaxProviderCard,
-      MistralProviderCard,
-      GroqProviderCard,
-      MoonshotProviderCard,
-      ZeroOneProviderCard,
-      ZhiPuProviderCard,
-    ];
-
-    set({ defaultModelProviderList }, false, n(`refreshDefaultModelList - ${params?.trigger}`));
+    const defaultModelProviderList = produce(DEFAULT_MODEL_PROVIDER_LIST, (draft) => {
+      const openai = draft.find((d) => d.id === ModelProvider.OpenAI);
+      if (openai) openai.chatModels = mergeModels('openai', openai.chatModels);
+
+      const azure = draft.find((d) => d.id === ModelProvider.Azure);
+      if (azure) azure.chatModels = mergeModels('azure', azure.chatModels);
+
+      const ollama = draft.find((d) => d.id === ModelProvider.Ollama);
+      if (ollama) ollama.chatModels = mergeModels('ollama', ollama.chatModels);
+
+      const openrouter = draft.find((d) => d.id === ModelProvider.OpenRouter);
+      if (openrouter) openrouter.chatModels = mergeModels('openrouter', openrouter.chatModels);
+
+      const togetherai = draft.find((d) => d.id === ModelProvider.TogetherAI);
+      if (togetherai) togetherai.chatModels = mergeModels('togetherai', togetherai.chatModels);
+    });
+
+    set({ defaultModelProviderList }, false, `refreshDefaultModelList - ${params?.trigger}`);
 
     get().refreshModelProviderList({ trigger: 'refreshDefaultModelList' });
   },
-
   refreshModelProviderList: (params) => {
     const modelProviderList = get().defaultModelProviderList.map((list) => ({
       ...list,
@@ -143,7 +119,7 @@ export const llmSettingsSlice: StateCreator<
       enabled: modelProviderSelectors.isProviderEnabled(list.id as any)(get()),
     }));
 
-    set({ modelProviderList }, false, n(`refreshModelList - ${params?.trigger}`));
+    set({ modelProviderList }, false, `refreshModelList - ${params?.trigger}`);
   },
 
   removeEnabledModels: async (provider, model) => {
@@ -157,14 +133,44 @@ export const llmSettingsSlice: StateCreator<
   setModelProviderConfig: async (provider, config) => {
     await get().setSettings({ languageModel: { [provider]: config } });
   },
+
   toggleEditingCustomModelCard: (params) => {
     set({ editingCustomCardModel: params }, false, 'toggleEditingCustomModelCard');
   },
-
   toggleProviderEnabled: async (provider, enabled) => {
     await get().setSettings({ languageModel: { [provider]: { enabled } } });
   },
 
+  updateEnabledModels: async (provider, value, options) => {
+    const { dispatchCustomModelCards, setModelProviderConfig } = get();
+    const enabledModels = modelProviderSelectors.getEnableModelsById(provider)(get());
+
+    // if there is a new model, add it to `customModelCards`
+    const pools = options.map(async (option: { label?: string; value?: string }, index: number) => {
+      // if is a known model, it should have value
+      // if is an unknown model, the option will be {}
+      if (option.value) return;
+
+      const modelId = value[index];
+
+      // if is in enabledModels, it means it's a removed model
+      if (enabledModels?.some((m) => modelId === m)) return;
+
+      await dispatchCustomModelCards(provider, {
+        modelCard: { id: modelId },
+        type: 'add',
+      });
+    });
+
+    // TODO: 当前的这个 pool 方法并不是最好的实现，因为它会触发 setModelProviderConfig 的多次更新。
+    // 理论上应该合并这些变更，然后最后只做一次触发
+    // 因此后续的做法应该是将 dispatchCustomModelCards 改造为同步方法，并在最后做一次异步更新
+    // 对应需要改造 'should add new custom model to customModelCards' 这一个单测
+    await Promise.all(pools);
+
+    await setModelProviderConfig(provider, { enabledModels: value.filter(Boolean) });
+  },
+
   useFetchProviderModelList: (provider, enabledAutoFetch) =>
     useSWR<ChatModelCard[] | undefined>(
       [provider, enabledAutoFetch],

package/src/store/user/slices/modelList/initialState.ts

@@ -0,0 +1,15 @@
+import { DEFAULT_MODEL_PROVIDER_LIST } from '@/config/modelProviders';
+import { ModelProviderCard } from '@/types/llm';
+import { ServerLanguageModel } from '@/types/serverConfig';
+
+export interface ModelListState {
+  defaultModelProviderList: ModelProviderCard[];
+  editingCustomCardModel?: { id: string; provider: string } | undefined;
+  modelProviderList: ModelProviderCard[];
+  serverLanguageModel?: ServerLanguageModel;
+}
+
+export const initialModelListState: ModelListState = {
+  defaultModelProviderList: DEFAULT_MODEL_PROVIDER_LIST,
+  modelProviderList: DEFAULT_MODEL_PROVIDER_LIST,
+};

package/src/store/user/slices/modelList/selectors/index.ts

@@ -0,0 +1,2 @@
+export { modelConfigSelectors } from './modelConfig';
+export { modelProviderSelectors } from './modelProvider';

package/src/store/user/slices/{settings → modelList}/selectors/modelConfig.test.ts

@@ -3,7 +3,8 @@ import { describe, expect, it } from 'vitest';
 import { UserStore } from '@/store/user';
 import { merge } from '@/utils/merge';
 
-import { UserSettingsState, initialSettingsState } from '../initialState';
+import { UserState } from '../../../initialState';
+import { UserSettingsState, initialSettingsState } from '../../settings/initialState';
 import { modelConfigSelectors } from './modelConfig';
 
 describe('modelConfigSelectors', () => {
@@ -121,7 +122,7 @@ describe('modelConfigSelectors', () => {
           id: 'custom-model-2',
           provider: 'perplexity',
         },
-      } as UserSettingsState) as unknown as UserStore;
+      } as UserState) as unknown as UserStore;
 
       const currentEditingModelCard = modelConfigSelectors.currentEditingCustomModelCard(s);
 

package/src/store/user/slices/{settings → modelList}/selectors/modelConfig.ts

@@ -1,7 +1,7 @@
 import { GlobalLLMProviderKey } from '@/types/settings';
 
 import { UserStore } from '../../../store';
-import { currentLLMSettings, getProviderConfigById } from './settings';
+import { currentLLMSettings, getProviderConfigById } from '../../settings/selectors/settings';
 
 const isProviderEnabled = (provider: GlobalLLMProviderKey) => (s: UserStore) =>
   getProviderConfigById(provider)(s)?.enabled || false;

package/src/store/user/slices/{settings → modelList}/selectors/modelProvider.test.ts

@@ -2,21 +2,21 @@ import { describe, expect, it } from 'vitest';
 
 import { merge } from '@/utils/merge';
 
+import { UserState, initialState } from '../../../initialState';
 import { UserStore, useUserStore } from '../../../store';
-import { UserSettingsState, initialSettingsState } from '../initialState';
 import { getDefaultModeProviderById, modelProviderSelectors } from './modelProvider';
 
 describe('modelProviderSelectors', () => {
   describe('getDefaultModeProviderById', () => {
     it('should return the correct ModelProviderCard when provider ID matches', () => {
-      const s = merge(initialSettingsState, {}) as unknown as UserStore;
+      const s = merge(initialState, {}) as unknown as UserStore;
 
       const result = getDefaultModeProviderById('openai')(s);
       expect(result).not.toBeUndefined();
     });
 
     it('should return undefined when provider ID does not exist', () => {
-      const s = merge(initialSettingsState, {}) as unknown as UserStore;
+      const s = merge(initialState, {}) as unknown as UserStore;
       const result = getDefaultModeProviderById('nonExistingProvider')(s);
       expect(result).toBeUndefined();
     });
@@ -24,7 +24,7 @@ describe('modelProviderSelectors', () => {
 
   describe('getModelCardsById', () => {
     it('should return model cards including custom model cards', () => {
-      const s = merge(initialSettingsState, {
+      const s = merge(initialState, {
         settings: {
           languageModel: {
             perplexity: {
@@ -32,7 +32,7 @@ describe('modelProviderSelectors', () => {
             },
           },
         },
-      } as UserSettingsState) as unknown as UserStore;
+      } as UserState) as unknown as UserStore;
 
       const modelCards = modelProviderSelectors.getModelCardsById('perplexity')(s);
 
@@ -46,14 +46,14 @@ describe('modelProviderSelectors', () => {
 
   describe('defaultEnabledProviderModels', () => {
     it('should return enabled models for a given provider', () => {
-      const s = merge(initialSettingsState, {}) as unknown as UserStore;
+      const s = merge(initialState, {}) as unknown as UserStore;
 
       const result = modelProviderSelectors.getDefaultEnabledModelsById('openai')(s);
       expect(result).toEqual(['gpt-3.5-turbo', 'gpt-4-turbo', 'gpt-4o']);
     });
 
     it('should return undefined for a non-existing provider', () => {
-      const s = merge(initialSettingsState, {}) as unknown as UserStore;
+      const s = merge(initialState, {}) as unknown as UserStore;
 
       const result = modelProviderSelectors.getDefaultEnabledModelsById('nonExistingProvider')(s);
       expect(result).toBeUndefined();

package/src/store/user/slices/{settings → modelList}/selectors/modelProvider.ts

@@ -6,7 +6,7 @@ import { ServerModelProviderConfig } from '@/types/serverConfig';
 import { GlobalLLMProviderKey } from '@/types/settings';
 
 import { UserStore } from '../../../store';
-import { currentSettings, getProviderConfigById } from './settings';
+import { currentSettings, getProviderConfigById } from '../../settings/selectors/settings';
 
 /**
  * get the server side model cards
@@ -14,9 +14,7 @@ import { currentSettings, getProviderConfigById } from './settings';
 const serverProviderModelCards =
   (provider: GlobalLLMProviderKey) =>
   (s: UserStore): ChatModelCard[] | undefined => {
-    const config = s.serverConfig.languageModel?.[provider] as
-      | ServerModelProviderConfig
-      | undefined;
+    const config = s.serverLanguageModel?.[provider] as ServerModelProviderConfig | undefined;
 
     if (!config) return;