@lobehub/lobehub 2.0.0-next.15 → 2.0.0-next.16

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

@@ -1,359 +0,0 @@
-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 { ProviderConfig } from '@/types/user/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<ProviderConfig> = { fetchOnClient: true };
-
-      // 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 } },
-        expect.any(AbortSignal),
-      );
-    });
-  });
-
-  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' }] },
-          },
-        });
-      });
-
-      await act(async () => {
-        await 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', async () => {
-      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',
-                  contextWindowTokens: 128000,
-                  enabled: true,
-                },
-                {
-                  displayName: 'ChatGPT-4 Vision',
-                  functionCall: true,
-                  id: 'gpt-4-turbo-2024-04-09',
-                  contextWindowTokens: 128000,
-                  vision: true,
-                  enabled: true,
-                },
-              ],
-            },
-          },
-        });
-      });
-
-      await act(async () => {
-        await 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',
-          contextWindowTokens: 128000,
-        },
-        {
-          displayName: 'ChatGPT-4 Vision',
-          enabled: true,
-          functionCall: true,
-          id: 'gpt-4-turbo-2024-04-09',
-          contextWindowTokens: 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
-      const model = ollamaList?.chatModels.find((c) => c.id === 'llava');
-
-      expect(model).toMatchSnapshot();
-    });
-
-    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'] } } },
-        expect.any(AbortSignal),
-      );
-    });
-  });
-
-  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 } } },
-        expect.any(AbortSignal),
-      );
-    });
-
-    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 } } },
-        expect.any(AbortSignal),
-      );
-    });
-  });
-
-  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'],
-            },
-          },
-        },
-        expect.any(AbortSignal),
-      );
-    });
-
-    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'] } },
-        },
-        expect.any(AbortSignal),
-      );
-    });
-  });
-
-  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, 'getModels').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, 'getModels').mockResolvedValueOnce([]);
-
-      renderHook(() => result.current.useFetchProviderModelList(provider, enabledAutoFetch));
-
-      await waitFor(() => {
-        expect(spyOn).not.toHaveBeenCalled();
-      });
-    });
-  });
-});

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

@@ -1,223 +0,0 @@
-import type {
-  ChatModelCard,
-  GlobalLLMProviderKey,
-  ModelProviderCard,
-  UserKeyVaults,
-  UserModelProviderConfig,
-} from '@lobechat/types';
-import { produce } from 'immer';
-import { ModelProvider } from 'model-bank';
-import useSWR, { SWRResponse } from 'swr';
-import type { StateCreator } from 'zustand/vanilla';
-
-import type { UserStore } from '@/store/user';
-
-import { settingsSelectors } from '../settings/selectors';
-import { CustomModelCardDispatch, customModelCardsReducer } from './reducers/customModelCard';
-import { modelProviderSelectors } from './selectors/modelProvider';
-
-/**
- * 设置操作
- */
-export interface ModelListAction {
-  clearObtainedModels: (provider: GlobalLLMProviderKey) => Promise<void>;
-  dispatchCustomModelCards: (
-    provider: GlobalLLMProviderKey,
-    payload: CustomModelCardDispatch,
-  ) => Promise<void>;
-  /**
-   * make sure the default model provider list is sync to latest state
-   */
-  refreshDefaultModelProviderList: (params?: { trigger?: string }) => Promise<void>;
-  refreshModelProviderList: (params?: { trigger?: string }) => void;
-  removeEnabledModels: (provider: GlobalLLMProviderKey, model: string) => Promise<void>;
-  setModelProviderConfig: <T extends GlobalLLMProviderKey>(
-    provider: T,
-    config: Partial<UserModelProviderConfig[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>;
-
-  updateKeyVaultConfig: <T extends GlobalLLMProviderKey>(
-    provider: T,
-    config: Partial<UserKeyVaults[T]>,
-  ) => Promise<void>;
-
-  updateKeyVaultSettings: (key: string, config: any) => Promise<void>;
-
-  useFetchProviderModelList: (
-    provider: GlobalLLMProviderKey,
-    enabledAutoFetch: boolean,
-  ) => SWRResponse;
-}
-
-export const createModelListSlice: StateCreator<
-  UserStore,
-  [['zustand/devtools', never]],
-  [],
-  ModelListAction
-> = (set, get) => ({
-  clearObtainedModels: async (provider: GlobalLLMProviderKey) => {
-    await get().setModelProviderConfig(provider, {
-      remoteModelCards: [],
-    });
-
-    await get().refreshDefaultModelProviderList();
-  },
-  dispatchCustomModelCards: async (provider, payload) => {
-    const prevState = settingsSelectors.providerConfig(provider)(get());
-
-    if (!prevState) return;
-
-    const nextState = customModelCardsReducer(prevState.customModelCards, payload);
-
-    await get().setModelProviderConfig(provider, { customModelCards: nextState });
-  },
-  refreshDefaultModelProviderList: async (params) => {
-    /**
-     * Because we have several model cards sources, we need to merge the model cards
-     * the priority is below:
-     * 1 - server side model cards
-     * 2 - remote model cards
-     * 3 - default model cards
-     */
-
-    const mergeModels = (providerKey: GlobalLLMProviderKey, providerCard: ModelProviderCard) => {
-      // if the chat model is config in the server side, use the server side model cards
-      const serverChatModels = modelProviderSelectors.serverProviderModelCards(providerKey)(get());
-      const remoteChatModels = providerCard.modelList?.showModelFetcher
-        ? modelProviderSelectors.remoteProviderModelCards(providerKey)(get())
-        : undefined;
-
-      if (serverChatModels && serverChatModels.length > 0) {
-        return serverChatModels;
-      }
-      if (remoteChatModels && remoteChatModels.length > 0) {
-        return remoteChatModels;
-      }
-
-      return providerCard.chatModels;
-    };
-
-    const { DEFAULT_MODEL_PROVIDER_LIST } = await import('@/config/modelProviders');
-    const defaultModelProviderList = produce(DEFAULT_MODEL_PROVIDER_LIST, (draft) => {
-      Object.values(ModelProvider).forEach((id) => {
-        const provider = draft.find((d) => d.id === id);
-        if (provider) provider.chatModels = mergeModels(id as any, provider);
-      });
-    });
-
-    set({ defaultModelProviderList }, false, `refreshDefaultModelList - ${params?.trigger}`);
-
-    get().refreshModelProviderList({ trigger: 'refreshDefaultModelList' });
-  },
-  refreshModelProviderList: (params) => {
-    const modelProviderList = get().defaultModelProviderList.map((list) => {
-      const enabledModels = modelProviderSelectors.getEnableModelsById(list.id)(get());
-      return {
-        ...list,
-        chatModels: modelProviderSelectors
-          .getModelCardsById(list.id)(get())
-          ?.map((model) => {
-            if (!enabledModels) return model;
-
-            return {
-              ...model,
-              enabled: enabledModels?.some((m) => m === model.id),
-            };
-          }),
-        enabled: modelProviderSelectors.isProviderEnabled(list.id as any)(get()),
-      };
-    });
-
-    set({ modelProviderList }, false, `refreshModelList - ${params?.trigger}`);
-  },
-
-  removeEnabledModels: async (provider, model) => {
-    const config = settingsSelectors.providerConfig(provider)(get());
-
-    await get().setModelProviderConfig(provider, {
-      enabledModels: config?.enabledModels?.filter((s) => s !== model).filter(Boolean),
-    });
-  },
-
-  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) });
-  },
-
-  updateKeyVaultConfig: async (provider, config) => {
-    await get().setSettings({ keyVaults: { [provider]: config } });
-  },
-
-  updateKeyVaultSettings: async (provider, config) => {
-    await get().setSettings({ keyVaults: { [provider]: config } });
-  },
-
-  useFetchProviderModelList: (provider, enabledAutoFetch) =>
-    useSWR<ChatModelCard[] | undefined>(
-      [provider, enabledAutoFetch],
-      async ([p]) => {
-        const { modelsService } = await import('@/services/models');
-
-        return modelsService.getModels(p);
-      },
-      {
-        onSuccess: async (data) => {
-          if (data) {
-            await get().setModelProviderConfig(provider, {
-              latestFetchTime: Date.now(),
-              remoteModelCards: data,
-            });
-
-            get().refreshDefaultModelProviderList();
-          }
-        },
-        revalidateOnFocus: false,
-        revalidateOnMount: enabledAutoFetch,
-      },
-    ),
-});

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

@@ -1,15 +0,0 @@
-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,
-};