@lobehub/chat 0.147.7 → 0.147.8

package/src/features/ChatInput/ActionBar/Tools/index.tsx

@@ -46,7 +46,7 @@ const Tools = memo(() => {
   const { styles } = useStyles();
 
   const model = useSessionStore(agentSelectors.currentAgentModel);
-  const enableFC = useGlobalStore(modelProviderSelectors.modelEnabledFunctionCall(model));
+  const enableFC = useGlobalStore(modelProviderSelectors.isModelEnabledFunctionCall(model));
 
   return (
     <>

package/src/features/ChatInput/useChatInput.ts

@@ -15,7 +15,7 @@ export const useChatInput = () => {
   const onSend = useSendMessage();
 
   const model = useSessionStore(agentSelectors.currentAgentModel);
-  const canUpload = useGlobalStore(modelProviderSelectors.modelEnabledUpload(model));
+  const canUpload = useGlobalStore(modelProviderSelectors.isModelEnabledUpload(model));
 
   const [loading, value, onInput, onStop] = useChatStore((s) => [
     !!s.chatLoadingId,

package/src/features/Conversation/Error/APIKeyForm/ProviderApiKeyForm.tsx

@@ -5,7 +5,7 @@ import { ReactNode, memo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import { useGlobalStore } from '@/store/global';
-import { modelConfigSelectors } from '@/store/global/selectors';
+import { settingsSelectors } from '@/store/global/selectors';
 import { GlobalLLMProviderKey } from '@/types/settings';
 
 import { FormAction } from '../style';
@@ -24,8 +24,8 @@ const ProviderApiKeyForm = memo<ProviderApiKeyFormProps>(
     const [showProxy, setShow] = useState(false);
 
     const [apiKey, proxyUrl, setConfig] = useGlobalStore((s) => [
-      modelConfigSelectors.getConfigByProviderId(provider)(s)?.apiKey,
-      modelConfigSelectors.getConfigByProviderId(provider)(s)?.endpoint,
+      settingsSelectors.providerConfig(provider)(s)?.apiKey,
+      settingsSelectors.providerConfig(provider)(s)?.endpoint,
       s.setModelProviderConfig,
     ]);
 

package/src/features/ModelSwitchPanel/index.tsx

@@ -10,7 +10,7 @@ import { Flexbox } from 'react-layout-kit';
 
 import { ModelItemRender, ProviderItemRender } from '@/components/ModelSelect';
 import { useGlobalStore } from '@/store/global';
-import { modelConfigSelectors } from '@/store/global/selectors';
+import { modelProviderSelectors } from '@/store/global/selectors';
 import { useSessionStore } from '@/store/session';
 import { agentSelectors } from '@/store/session/selectors';
 import { ModelProviderCard } from '@/types/llm';
@@ -44,7 +44,10 @@ const ModelSwitchPanel = memo<PropsWithChildren>(({ children }) => {
   const updateAgentConfig = useSessionStore((s) => s.updateAgentConfig);
 
   const router = useRouter();
-  const enabledList = useGlobalStore(modelConfigSelectors.providerListForModelSelect, isEqual);
+  const enabledList = useGlobalStore(
+    modelProviderSelectors.modelProviderListForModelSelect,
+    isEqual,
+  );
 
   const items = useMemo(() => {
     const getModelItems = (provider: ModelProviderCard) => {

package/src/migrations/FromV3ToV4/fixtures/openai-output-v4.json

@@ -54,9 +54,7 @@
             {
               "displayName": "deerercsds",
               "enabled": true,
-              "functionCall": true,
-              "id": "deerercsds",
-              "vision": true
+              "id": "deerercsds"
             }
           ]
         }

package/src/migrations/FromV3ToV4/fixtures/openrouter-output-v4.json

@@ -48,16 +48,12 @@
             {
               "displayName": "01-ai/yi-34b-chat",
               "enabled": true,
-              "functionCall": true,
-              "id": "01-ai/yi-34b-chat",
-              "vision": true
+              "id": "01-ai/yi-34b-chat"
             },
             {
               "displayName": "huggingfaceh4/zephyr-7b-beta",
               "enabled": true,
-              "functionCall": true,
-              "id": "huggingfaceh4/zephyr-7b-beta",
-              "vision": true
+              "id": "huggingfaceh4/zephyr-7b-beta"
             }
           ]
         },

package/src/migrations/FromV3ToV4/index.ts

@@ -62,7 +62,10 @@ export class MigrationV3ToV4 implements Migration {
       };
     }
 
-    const customModelCards = transformToChatModelCards(openai.customModelName, []);
+    const customModelCards = transformToChatModelCards({
+      defaultChatModels: [],
+      modelString: openai.customModelName,
+    });
 
     return {
       azure: {
@@ -81,7 +84,10 @@ export class MigrationV3ToV4 implements Migration {
   };
 
   static migrateProvider = (provider: V3LegacyConfig): V4ProviderConfig => {
-    const customModelCards = transformToChatModelCards(provider.customModelName, []);
+    const customModelCards = transformToChatModelCards({
+      defaultChatModels: [],
+      modelString: provider.customModelName,
+    });
 
     return {
       apiKey: provider.apiKey,

package/src/services/_auth.ts

@@ -35,9 +35,7 @@ export const getProviderAuthPayload = (provider: string) => {
     }
 
     default: {
-      const config = modelConfigSelectors.getConfigByProviderId(provider)(
-        useGlobalStore.getState(),
-      );
+      const config = settingsSelectors.providerConfig(provider)(useGlobalStore.getState());
 
       return { apiKey: config?.apiKey, endpoint: config?.endpoint };
     }

package/src/services/chat.ts

@@ -9,7 +9,6 @@ import { filesSelectors, useFileStore } from '@/store/file';
 import { useGlobalStore } from '@/store/global';
 import {
   commonSelectors,
-  modelConfigSelectors,
   modelProviderSelectors,
   preferenceSelectors,
 } from '@/store/global/selectors';
@@ -91,7 +90,7 @@ class ChatService {
     const filterTools = toolSelectors.enabledSchema(enabledPlugins)(useToolStore.getState());
 
     // check this model can use function call
-    const canUseFC = modelProviderSelectors.modelEnabledFunctionCall(payload.model)(
+    const canUseFC = modelProviderSelectors.isModelEnabledFunctionCall(payload.model)(
       useGlobalStore.getState(),
     );
     // the rule that model can use tools:
@@ -137,7 +136,7 @@ class ChatService {
 
     // if the provider is Azure, get the deployment name as the request model
     if (provider === ModelProvider.Azure) {
-      const chatModelCards = modelConfigSelectors.getModelCardsByProviderId(provider)(
+      const chatModelCards = modelProviderSelectors.getModelCardsById(provider)(
         useGlobalStore.getState(),
       );
 
@@ -257,7 +256,7 @@ class ChatService {
 
       if (imageList.length === 0) return m.content;
 
-      const canUploadFile = modelProviderSelectors.modelEnabledUpload(model)(
+      const canUploadFile = modelProviderSelectors.isModelEnabledUpload(model)(
         useGlobalStore.getState(),
       );
 
@@ -292,7 +291,7 @@ class ChatService {
 
     return produce(postMessages, (draft) => {
       if (!tools || tools.length === 0) return;
-      const hasFC = modelProviderSelectors.modelEnabledFunctionCall(model)(
+      const hasFC = modelProviderSelectors.isModelEnabledFunctionCall(model)(
         useGlobalStore.getState(),
       );
       if (!hasFC) return;

package/src/store/global/slices/settings/actions/llm.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, it, vi } from 'vitest';
 
 import { userService } from '@/services/user';
 import { useGlobalStore } from '@/store/global';
-import { modelConfigSelectors } from '@/store/global/slices/settings/selectors';
+import { modelConfigSelectors, settingsSelectors } from '@/store/global/slices/settings/selectors';
 import { GeneralModelProviderConfig } from '@/types/settings';
 
 import { CustomModelCardDispatch, customModelCardsReducer } from '../reducers/customModelCard';
@@ -46,7 +46,7 @@ describe('LLMSettingsSliceAction', () => {
       const payload: CustomModelCardDispatch = { type: 'add', modelCard: { id: 'test-id' } };
 
       // Mock the selector to return undefined
-      vi.spyOn(modelConfigSelectors, 'getConfigByProviderId').mockReturnValue(() => undefined);
+      vi.spyOn(settingsSelectors, 'providerConfig').mockReturnValue(() => undefined);
       vi.spyOn(result.current, 'setModelProviderConfig');
 
       await act(async () => {

package/src/store/global/slices/settings/actions/llm.ts

@@ -6,7 +6,7 @@ import { ChatModelCard } from '@/types/llm';
 import { GlobalLLMConfig, GlobalLLMProviderKey } from '@/types/settings';
 
 import { CustomModelCardDispatch, customModelCardsReducer } from '../reducers/customModelCard';
-import { modelConfigSelectors } from '../selectors/modelConfig';
+import { settingsSelectors } from '../selectors/settings';
 
 /**
  * 设置操作
@@ -37,7 +37,7 @@ export const llmSettingsSlice: StateCreator<
   LLMSettingsAction
 > = (set, get) => ({
   dispatchCustomModelCards: async (provider, payload) => {
-    const prevState = modelConfigSelectors.getConfigByProviderId(provider)(get());
+    const prevState = settingsSelectors.providerConfig(provider)(get());
 
     if (!prevState) return;
 
@@ -47,7 +47,7 @@ export const llmSettingsSlice: StateCreator<
   },
 
   removeEnabledModels: async (provider, model) => {
-    const config = modelConfigSelectors.getConfigByProviderId(provider)(get());
+    const config = settingsSelectors.providerConfig(provider)(get());
 
     await get().setModelProviderConfig(provider, {
       enabledModels: config?.enabledModels?.filter((s) => s !== model).filter(Boolean),

package/src/store/global/slices/settings/selectors/modelConfig.test.ts

@@ -7,55 +7,6 @@ import { GlobalSettingsState, initialSettingsState } from '../initialState';
 import { modelConfigSelectors } from './modelConfig';
 
 describe('modelConfigSelectors', () => {
-  describe('providerListWithConfig', () => {
-    it('visible', () => {
-      const s = merge(initialSettingsState, {
-        settings: {
-          languageModel: {
-            ollama: {
-              enabledModels: ['llava'],
-            },
-          },
-        },
-      } as GlobalSettingsState) as unknown as GlobalStore;
-
-      const ollamaList = modelConfigSelectors
-        .providerListWithConfig(s)
-        .find((r) => r.id === 'ollama');
-
-      expect(ollamaList?.chatModels.find((c) => c.id === 'llava')).toEqual({
-        displayName: 'LLaVA 7B',
-        functionCall: false,
-        enabled: true,
-        id: 'llava',
-        tokens: 4000,
-        vision: true,
-      });
-    });
-    it('with user custom models', () => {
-      const s = merge(initialSettingsState, {
-        settings: {
-          languageModel: {
-            perplexity: {
-              customModelCards: [{ id: 'sonar-online', displayName: 'Sonar Online' }],
-            },
-          },
-        },
-      } as GlobalSettingsState) as unknown as GlobalStore;
-
-      const providerList = modelConfigSelectors
-        .providerListWithConfig(s)
-        .find((r) => r.id === 'perplexity');
-
-      expect(providerList?.chatModels.find((c) => c.id === 'sonar-online')).toEqual({
-        id: 'sonar-online',
-        displayName: 'Sonar Online',
-        enabled: false,
-        isCustom: true,
-      });
-    });
-  });
-
   describe('isProviderEnabled', () => {
     it('should return true if provider is enabled', () => {
       const s = merge(initialSettingsState, {
@@ -82,45 +33,6 @@ describe('modelConfigSelectors', () => {
     });
   });
 
-  describe('getModelCardsByProviderId', () => {
-    it('should return model cards including custom model cards', () => {
-      const s = merge(initialSettingsState, {
-        settings: {
-          languageModel: {
-            perplexity: {
-              customModelCards: [{ id: 'custom-model', displayName: 'Custom Model' }],
-            },
-          },
-        },
-      } as GlobalSettingsState) as unknown as GlobalStore;
-
-      const modelCards = modelConfigSelectors.getModelCardsByProviderId('perplexity')(s);
-
-      expect(modelCards).toContainEqual({
-        id: 'custom-model',
-        displayName: 'Custom Model',
-        isCustom: true,
-      });
-    });
-  });
-
-  describe('providerListForModelSelect', () => {
-    it('should return only enabled providers', () => {
-      const s = merge(initialSettingsState, {
-        settings: {
-          languageModel: {
-            perplexity: { enabled: true },
-            azure: { enabled: false },
-          },
-        },
-      } as GlobalSettingsState) as unknown as GlobalStore;
-
-      const enabledProviders = modelConfigSelectors.providerListForModelSelect(s);
-      expect(enabledProviders).toHaveLength(2);
-      expect(enabledProviders[1].id).toBe('perplexity');
-    });
-  });
-
   describe('getCustomModelCardById', () => {
     it('should return the custom model card with the given id and provider', () => {
       const s = merge(initialSettingsState, {

package/src/store/global/slices/settings/selectors/modelConfig.ts

@@ -1,76 +1,21 @@
-import { uniqBy } from 'lodash-es';
-
-import { ChatModelCard, ModelProviderCard } from '@/types/llm';
-import { GeneralModelProviderConfig, GlobalLLMProviderKey } from '@/types/settings';
+import { GlobalLLMProviderKey } from '@/types/settings';
 
 import { GlobalStore } from '../../../store';
-import { modelProviderSelectors } from './modelProvider';
-import { currentSettings } from './settings';
-
-const getConfigByProviderId = (provider: string) => (s: GlobalStore) =>
-  currentSettings(s).languageModel[provider as GlobalLLMProviderKey] as
-    | GeneralModelProviderConfig
-    | undefined;
-
-const getModeProviderById = (provider: string) => (s: GlobalStore) =>
-  modelProviderSelectors.providerModelList(s).find((s) => s.id === provider);
+import { currentLLMSettings, getProviderConfigById } from './settings';
 
 const isProviderEnabled = (provider: GlobalLLMProviderKey) => (s: GlobalStore) =>
-  currentSettings(s).languageModel[provider]?.enabled || false;
-
-const getEnableModelsByProviderId = (provider: string) => (s: GlobalStore) => {
-  if (!getConfigByProviderId(provider)(s)?.enabledModels) return;
-
-  return getConfigByProviderId(provider)(s)?.enabledModels?.filter(Boolean);
-};
-
-const getModelCardsByProviderId =
-  (provider: string) =>
-  (s: GlobalStore): ChatModelCard[] => {
-    const builtinCards = getModeProviderById(provider)(s)?.chatModels || [];
-
-    const userCards = (getConfigByProviderId(provider)(s)?.customModelCards || []).map((model) => ({
-      ...model,
-      isCustom: true,
-    }));
-
-    return uniqBy([...userCards, ...builtinCards], 'id');
-  };
+  getProviderConfigById(provider)(s)?.enabled || false;
 
 const getCustomModelCard =
   ({ id, provider }: { id?: string; provider?: string }) =>
   (s: GlobalStore) => {
     if (!provider) return;
 
-    const config = getConfigByProviderId(provider)(s);
+    const config = getProviderConfigById(provider)(s);
 
     return config?.customModelCards?.find((m) => m.id === id);
   };
 
-const providerListWithConfig = (s: GlobalStore): ModelProviderCard[] =>
-  modelProviderSelectors.providerModelList(s).map((list) => ({
-    ...list,
-    chatModels: getModelCardsByProviderId(list.id)(s)?.map((model) => {
-      const models = getEnableModelsByProviderId(list.id)(s);
-
-      if (!models) return model;
-
-      return {
-        ...model,
-        enabled: models?.some((m) => m === model.id),
-      };
-    }),
-    enabled: isProviderEnabled(list.id as any)(s),
-  }));
-
-const providerListForModelSelect = (s: GlobalStore): ModelProviderCard[] =>
-  providerListWithConfig(s)
-    .filter((s) => s.enabled)
-    .map((provider) => ({
-      ...provider,
-      chatModels: provider.chatModels.filter((model) => model.enabled),
-    }));
-
 const currentEditingCustomModelCard = (s: GlobalStore) => {
   if (!s.editingCustomCardModel) return;
   const { id, provider } = s.editingCustomCardModel;
@@ -81,36 +26,27 @@ const currentEditingCustomModelCard = (s: GlobalStore) => {
 const isAutoFetchModelsEnabled =
   (provider: GlobalLLMProviderKey) =>
   (s: GlobalStore): boolean => {
-    return getConfigByProviderId(provider)(s)?.autoFetchModelLists || false;
+    return getProviderConfigById(provider)(s)?.autoFetchModelLists || false;
   };
 
-const llmSettings = (s: GlobalStore) => currentSettings(s).languageModel;
-
-const openAIConfig = (s: GlobalStore) => llmSettings(s).openai;
-const bedrockConfig = (s: GlobalStore) => llmSettings(s).bedrock;
-const ollamaConfig = (s: GlobalStore) => llmSettings(s).ollama;
-const azureConfig = (s: GlobalStore) => llmSettings(s).azure;
+const openAIConfig = (s: GlobalStore) => currentLLMSettings(s).openai;
+const bedrockConfig = (s: GlobalStore) => currentLLMSettings(s).bedrock;
+const ollamaConfig = (s: GlobalStore) => currentLLMSettings(s).ollama;
+const azureConfig = (s: GlobalStore) => currentLLMSettings(s).azure;
 
-const isAzureEnabled = (s: GlobalStore) => llmSettings(s).azure.enabled;
+const isAzureEnabled = (s: GlobalStore) => currentLLMSettings(s).azure.enabled;
 
-/* eslint-disable sort-keys-fix/sort-keys-fix,  */
 export const modelConfigSelectors = {
-  isAutoFetchModelsEnabled,
-  isProviderEnabled,
-  currentEditingCustomModelCard,
+  azureConfig,
+  bedrockConfig,
 
-  getConfigByProviderId,
-  getEnableModelsByProviderId,
-  getModelCardsByProviderId,
+  currentEditingCustomModelCard,
   getCustomModelCard,
 
-  providerListWithConfig,
-  providerListForModelSelect,
-
-  openAIConfig,
-  azureConfig,
-  bedrockConfig,
+  isAutoFetchModelsEnabled,
+  isAzureEnabled,
+  isProviderEnabled,
   ollamaConfig,
 
-  isAzureEnabled,
+  openAIConfig,
 };

package/src/store/global/slices/settings/selectors/modelProvider.test.ts

@@ -1,54 +1,138 @@
 import { describe, expect, it } from 'vitest';
 
-import { DEFAULT_SETTINGS } from '@/const/settings';
-import { agentSelectors } from '@/store/session/slices/agent';
 import { merge } from '@/utils/merge';
 
 import { GlobalStore, useGlobalStore } from '../../../store';
-import { initialSettingsState } from '../initialState';
-import { modelProviderSelectors } from './modelProvider';
+import { GlobalSettingsState, initialSettingsState } from '../initialState';
+import { getDefaultModeProviderById, modelProviderSelectors } from './modelProvider';
 
 describe('modelProviderSelectors', () => {
+  describe('providerListWithConfig', () => {
+    it('visible', () => {
+      const s = merge(initialSettingsState, {
+        settings: {
+          languageModel: {
+            ollama: {
+              enabledModels: ['llava'],
+            },
+          },
+        },
+      } as GlobalSettingsState) as unknown as GlobalStore;
+
+      const ollamaList = modelProviderSelectors.modelProviderList(s).find((r) => r.id === 'ollama');
+
+      expect(ollamaList?.chatModels.find((c) => c.id === 'llava')).toEqual({
+        displayName: 'LLaVA 7B',
+        functionCall: false,
+        enabled: true,
+        id: 'llava',
+        tokens: 4000,
+        vision: true,
+      });
+    });
+    it('with user custom models', () => {
+      const s = merge(initialSettingsState, {
+        settings: {
+          languageModel: {
+            perplexity: {
+              customModelCards: [{ id: 'sonar-online', displayName: 'Sonar Online' }],
+            },
+          },
+        },
+      } as GlobalSettingsState) as unknown as GlobalStore;
+
+      const providerList = modelProviderSelectors
+        .modelProviderList(s)
+        .find((r) => r.id === 'perplexity');
+
+      expect(providerList?.chatModels.find((c) => c.id === 'sonar-online')).toEqual({
+        id: 'sonar-online',
+        displayName: 'Sonar Online',
+        enabled: false,
+        isCustom: true,
+      });
+    });
+  });
+
+  describe('providerListForModelSelect', () => {
+    it('should return only enabled providers', () => {
+      const s = merge(initialSettingsState, {
+        settings: {
+          languageModel: {
+            perplexity: { enabled: true },
+            azure: { enabled: false },
+          },
+        },
+      } as GlobalSettingsState) as unknown as GlobalStore;
+
+      const enabledProviders = modelProviderSelectors.modelProviderListForModelSelect(s);
+      expect(enabledProviders).toHaveLength(2);
+      expect(enabledProviders[1].id).toBe('perplexity');
+    });
+  });
+
   describe('providerCard', () => {
     it('should return the correct ModelProviderCard when provider ID matches', () => {
       const s = merge(initialSettingsState, {}) as unknown as GlobalStore;
 
-      const result = modelProviderSelectors.providerCard('openai')(s);
+      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 GlobalStore;
-      const result = modelProviderSelectors.providerCard('nonExistingProvider')(s);
+      const result = getDefaultModeProviderById('nonExistingProvider')(s);
       expect(result).toBeUndefined();
     });
   });
 
+  describe('getModelCardsById', () => {
+    it('should return model cards including custom model cards', () => {
+      const s = merge(initialSettingsState, {
+        settings: {
+          languageModel: {
+            perplexity: {
+              customModelCards: [{ id: 'custom-model', displayName: 'Custom Model' }],
+            },
+          },
+        },
+      } as GlobalSettingsState) as unknown as GlobalStore;
+
+      const modelCards = modelProviderSelectors.getModelCardsById('perplexity')(s);
+
+      expect(modelCards).toContainEqual({
+        id: 'custom-model',
+        displayName: 'Custom Model',
+        isCustom: true,
+      });
+    });
+  });
+
   describe('defaultEnabledProviderModels', () => {
     it('should return enabled models for a given provider', () => {
       const s = merge(initialSettingsState, {}) as unknown as GlobalStore;
 
-      const result = modelProviderSelectors.defaultEnabledProviderModels('openai')(s);
+      const result = modelProviderSelectors.getDefaultEnabledModelsById('openai')(s);
       expect(result).toEqual(['gpt-3.5-turbo', 'gpt-4-turbo']);
     });
 
     it('should return undefined for a non-existing provider', () => {
       const s = merge(initialSettingsState, {}) as unknown as GlobalStore;
 
-      const result = modelProviderSelectors.defaultEnabledProviderModels('nonExistingProvider')(s);
+      const result = modelProviderSelectors.getDefaultEnabledModelsById('nonExistingProvider')(s);
       expect(result).toBeUndefined();
     });
   });
   describe('modelEnabledVision', () => {
     it('should return true if the model has vision ability', () => {
-      const hasAbility = modelProviderSelectors.modelEnabledVision('gpt-4-vision-preview')(
+      const hasAbility = modelProviderSelectors.isModelEnabledVision('gpt-4-vision-preview')(
         useGlobalStore.getState(),
       );
       expect(hasAbility).toBeTruthy();
     });
 
     it('should return false if the model does not have vision ability', () => {
-      const hasAbility = modelProviderSelectors.modelEnabledVision('some-other-model')(
+      const hasAbility = modelProviderSelectors.isModelEnabledVision('some-other-model')(
         useGlobalStore.getState(),
       );
 
@@ -56,7 +140,7 @@ describe('modelProviderSelectors', () => {
     });
 
     it('should return false if the model include vision in id', () => {
-      const hasAbility = modelProviderSelectors.modelEnabledVision('some-other-model-vision')(
+      const hasAbility = modelProviderSelectors.isModelEnabledVision('some-other-model-vision')(
         useGlobalStore.getState(),
       );
 
@@ -66,14 +150,14 @@ describe('modelProviderSelectors', () => {
 
   describe('modelEnabledFiles', () => {
     it('should return false if the model does not have file ability', () => {
-      const enabledFiles = modelProviderSelectors.modelEnabledFiles('gpt-4-vision-preview')(
+      const enabledFiles = modelProviderSelectors.isModelEnabledFiles('gpt-4-vision-preview')(
         useGlobalStore.getState(),
       );
       expect(enabledFiles).toBeFalsy();
     });
 
     it('should return true if the model has file ability', () => {
-      const enabledFiles = modelProviderSelectors.modelEnabledFiles('gpt-4-all')(
+      const enabledFiles = modelProviderSelectors.isModelEnabledFiles('gpt-4-all')(
         useGlobalStore.getState(),
       );
       expect(enabledFiles).toBeTruthy();
@@ -82,14 +166,14 @@ describe('modelProviderSelectors', () => {
 
   describe('modelHasMaxToken', () => {
     it('should return true if the model is in the list of models that show tokens', () => {
-      const show = modelProviderSelectors.modelHasMaxToken('gpt-3.5-turbo')(
+      const show = modelProviderSelectors.isModelHasMaxToken('gpt-3.5-turbo')(
         useGlobalStore.getState(),
       );
       expect(show).toBeTruthy();
     });
 
     it('should return false if the model is not in the list of models that show tokens', () => {
-      const show = modelProviderSelectors.modelHasMaxToken('some-other-model')(
+      const show = modelProviderSelectors.isModelHasMaxToken('some-other-model')(
         useGlobalStore.getState(),
       );
       expect(show).toBe(false);