@lobehub/chat 0.122.1 → 0.122.3

package/src/store/global/slices/settings/action.test.ts

@@ -1,75 +1,102 @@
-import { act, renderHook } from '@testing-library/react';
+import { act, renderHook, waitFor } from '@testing-library/react';
 import { DeepPartial } from 'utility-types';
 import { describe, expect, it, vi } from 'vitest';
+import { withSWR } from '~test-utils';
 
 import { DEFAULT_AGENT, DEFAULT_SETTINGS } from '@/const/settings';
+import { userService } from '@/services/user';
 import { useGlobalStore } from '@/store/global';
 import { SettingsTabs } from '@/store/global/initialState';
 import { LobeAgentSettings } from '@/types/session';
 import { GlobalSettings, OpenAIConfig } from '@/types/settings';
 
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-vi.mock('@/utils/uuid', () => ({
-  nanoid: vi.fn(() => 'unique-id'),
+// Mock userService
+vi.mock('@/services/user', () => ({
+  userService: {
+    updateUserSettings: vi.fn(),
+    resetUserSettings: vi.fn(),
+  },
 }));
 
 describe('SettingsAction', () => {
   describe('importAppSettings', () => {
-    it('should import app settings', () => {
+    it('should import app settings', async () => {
       const { result } = renderHook(() => useGlobalStore());
       const newSettings: GlobalSettings = {
         ...DEFAULT_SETTINGS,
         themeMode: 'dark',
       };
 
-      act(() => {
-        result.current.importAppSettings(newSettings);
+      // Mock the internal setSettings function call
+      const setSettingsSpy = vi.spyOn(result.current, 'setSettings');
+
+      // Perform the action
+      await act(async () => {
+        await result.current.importAppSettings(newSettings);
       });
 
-      expect(result.current.settings).toEqual(newSettings);
+      // Assert that setSettings was called with the correct settings
+      expect(setSettingsSpy).toHaveBeenCalledWith({
+        ...DEFAULT_SETTINGS,
+        password: undefined,
+        themeMode: 'dark',
+      });
+
+      // Assert that the state has been updated
+      expect(userService.updateUserSettings).toHaveBeenCalledWith({ themeMode: 'dark' });
+
+      // Restore the spy
+      setSettingsSpy.mockRestore();
     });
   });
 
   describe('resetSettings', () => {
-    it('should reset settings to default', () => {
+    it('should reset settings to default', async () => {
       const { result } = renderHook(() => useGlobalStore());
 
-      act(() => {
-        result.current.resetSettings();
+      // Perform the action
+      await act(async () => {
+        await result.current.resetSettings();
       });
 
-      expect(result.current.settings).toEqual(DEFAULT_SETTINGS);
+      // Assert that resetUserSettings was called
+      expect(userService.resetUserSettings).toHaveBeenCalled();
+
+      // Assert that the state has been updated to default settings
+      expect(result.current.settings).toEqual({});
     });
   });
 
   describe('setOpenAIConfig', () => {
-    it('should set OpenAI configuration', () => {
+    it('should set OpenAI configuration', async () => {
       const { result } = renderHook(() => useGlobalStore());
-      const openAIConfig: Partial<OpenAIConfig> = { OPENAI_API_KEY: 'test' };
+      const openAIConfig: Partial<OpenAIConfig> = { OPENAI_API_KEY: 'test-key' };
 
-      act(() => {
-        result.current.setOpenAIConfig(openAIConfig);
+      // Perform the action
+      await act(async () => {
+        await result.current.setOpenAIConfig(openAIConfig);
       });
 
-      expect(result.current.settings.languageModel.openAI.OPENAI_API_KEY).toEqual(
-        openAIConfig.OPENAI_API_KEY,
-      );
+      // Assert that updateUserSettings was called with the correct OpenAI configuration
+      expect(userService.updateUserSettings).toHaveBeenCalledWith({
+        languageModel: {
+          openAI: openAIConfig,
+        },
+      });
     });
   });
-
   describe('setSettings', () => {
-    it('should set partial settings', () => {
+    it('should set partial settings', async () => {
       const { result } = renderHook(() => useGlobalStore());
       const partialSettings: Partial<GlobalSettings> = { themeMode: 'dark' };
 
-      act(() => {
-        result.current.setSettings(partialSettings);
+      // Perform the action
+      await act(async () => {
+        await result.current.setSettings(partialSettings);
       });
 
-      expect(result.current.settings.themeMode).toEqual('dark');
+      // Assert that updateUserSettings was called with the correct settings
+      expect(userService.updateUserSettings).toHaveBeenCalledWith(partialSettings);
     });
   });
 
@@ -86,32 +113,34 @@ describe('SettingsAction', () => {
   });
 
   describe('switchThemeMode', () => {
-    it('should switch theme mode', () => {
+    it('should switch theme mode', async () => {
       const { result } = renderHook(() => useGlobalStore());
+      const themeMode = 'light';
 
-      act(() => {
-        result.current.switchThemeMode('light');
+      // Perform the action
+      await act(async () => {
+        await result.current.switchThemeMode(themeMode);
       });
 
-      expect(result.current.settings.themeMode).toEqual('light');
+      // Assert that updateUserSettings was called with the correct theme mode
+      expect(userService.updateUserSettings).toHaveBeenCalledWith({ themeMode });
     });
   });
 
   describe('updateDefaultAgent', () => {
-    it('should update default agent settings', () => {
+    it('should update default agent settings', async () => {
       const { result } = renderHook(() => useGlobalStore());
-      const updatedAgent: DeepPartial<LobeAgentSettings> = {
+      const updatedAgent: Partial<LobeAgentSettings> = {
         meta: { title: 'docs' },
       };
 
-      act(() => {
-        result.current.updateDefaultAgent(updatedAgent);
+      // Perform the action
+      await act(async () => {
+        await result.current.updateDefaultAgent(updatedAgent);
       });
 
-      expect(result.current.settings.defaultAgent).toEqual({
-        ...DEFAULT_AGENT,
-        ...updatedAgent,
-      });
+      // Assert that updateUserSettings was called with the merged agent settings
+      expect(userService.updateUserSettings).toHaveBeenCalledWith({ defaultAgent: updatedAgent });
     });
   });
 });

package/src/store/global/slices/settings/action.ts

@@ -1,42 +1,27 @@
 import { ThemeMode } from 'antd-style';
 import isEqual from 'fast-deep-equal';
-import { produce } from 'immer';
 import { DeepPartial } from 'utility-types';
 import type { StateCreator } from 'zustand/vanilla';
 
-import { DEFAULT_AGENT, DEFAULT_SETTINGS } from '@/const/settings';
+import { userService } from '@/services/user';
 import type { GlobalStore } from '@/store/global';
 import { SettingsTabs } from '@/store/global/initialState';
 import { LobeAgentSettings } from '@/types/session';
 import type { GlobalSettings, OpenAIConfig } from '@/types/settings';
+import { difference } from '@/utils/difference';
 import { merge } from '@/utils/merge';
-import { setNamespace } from '@/utils/storeDebug';
-
-const n = setNamespace('settings');
 
 /**
  * 设置操作
  */
 export interface SettingsAction {
-  importAppSettings: (settings: GlobalSettings) => void;
-  /**
-   * 重置设置
-   */
-  resetSettings: () => void;
-  setOpenAIConfig: (config: Partial<OpenAIConfig>) => void;
-  /**
-   * 设置部分配置设置
-   * @param settings - 部分配置设置
-   */
-  setSettings: (settings: DeepPartial<GlobalSettings>) => void;
-
+  importAppSettings: (settings: GlobalSettings) => Promise<void>;
+  resetSettings: () => Promise<void>;
+  setOpenAIConfig: (config: Partial<OpenAIConfig>) => Promise<void>;
+  setSettings: (settings: DeepPartial<GlobalSettings>) => Promise<void>;
   switchSettingTabs: (tab: SettingsTabs) => void;
-  /**
-   * 设置主题模式
-   * @param themeMode - 主题模式
-   */
-  switchThemeMode: (themeMode: ThemeMode) => void;
-  updateDefaultAgent: (agent: DeepPartial<LobeAgentSettings>) => void;
+  switchThemeMode: (themeMode: ThemeMode) => Promise<void>;
+  updateDefaultAgent: (agent: DeepPartial<LobeAgentSettings>) => Promise<void>;
 }
 
 export const createSettingsSlice: StateCreator<
@@ -45,49 +30,40 @@ export const createSettingsSlice: StateCreator<
   [],
   SettingsAction
 > = (set, get) => ({
-  importAppSettings: (importAppSettings) => {
+  importAppSettings: async (importAppSettings) => {
     const { setSettings } = get();
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { password: _, ...settings } = importAppSettings;
 
-    setSettings({
-      ...settings,
-      // 如果用户存在用户头像，那么不做导入
-      avatar: !get().settings.avatar ? settings.avatar : get().settings.avatar,
-    });
-  },
-  resetDefaultAgent: () => {
-    const settings = produce(get().settings, (draft: GlobalSettings) => {
-      draft.defaultAgent = DEFAULT_AGENT;
-    });
-    set({ settings }, false, n('resetDefaultAgent'));
+    await setSettings(settings);
   },
-  resetSettings: () => {
-    set({ settings: DEFAULT_SETTINGS }, false, n('resetSettings'));
+  resetSettings: async () => {
+    await userService.resetUserSettings();
+    await get().refreshUserConfig();
   },
-  setOpenAIConfig: (config) => {
-    get().setSettings({ languageModel: { openAI: config } });
+  setOpenAIConfig: async (config) => {
+    await get().setSettings({ languageModel: { openAI: config } });
   },
-  setSettings: (settings) => {
-    const prevSetting = get().settings;
+  setSettings: async (settings) => {
+    const { settings: prevSetting, defaultSettings } = get();
+
     const nextSettings = merge(prevSetting, settings);
 
     if (isEqual(prevSetting, nextSettings)) return;
 
-    set({ settings: merge(prevSetting, settings) }, false, n('setSettings', settings));
+    const diffs = difference(nextSettings, defaultSettings);
+
+    await userService.updateUserSettings(diffs);
+    await get().refreshUserConfig();
   },
 
   switchSettingTabs: (tab) => {
     set({ settingsTab: tab });
   },
-  switchThemeMode: (themeMode) => {
-    get().setSettings({ themeMode });
+  switchThemeMode: async (themeMode) => {
+    await get().setSettings({ themeMode });
   },
-  updateDefaultAgent: (agent) => {
-    const settings = produce(get().settings, (draft: GlobalSettings) => {
-      draft.defaultAgent = merge(draft.defaultAgent, agent);
-    });
-
-    set({ settings }, false, n('updateDefaultAgent', agent));
+  updateDefaultAgent: async (defaultAgent) => {
+    await get().setSettings({ defaultAgent });
   },
 });

package/src/store/global/slices/settings/initialState.ts

@@ -1,15 +1,17 @@
+import { DeepPartial } from 'utility-types';
+
 import { DEFAULT_SETTINGS } from '@/const/settings';
-import type { GlobalServerConfig, GlobalSettings } from '@/types/settings';
+import { GlobalServerConfig, GlobalSettings } from '@/types/settings';
 
 export interface GlobalSettingsState {
+  avatar?: string;
+  defaultSettings: GlobalSettings;
   serverConfig: GlobalServerConfig;
-  /**
-   * @localStorage
-   */
-  settings: GlobalSettings;
+  settings: DeepPartial<GlobalSettings>;
 }
 
 export const initialSettingsState: GlobalSettingsState = {
+  defaultSettings: DEFAULT_SETTINGS,
   serverConfig: {},
-  settings: DEFAULT_SETTINGS,
+  settings: {},
 };

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

@@ -0,0 +1,100 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`modelProviderSelectors > CUSTOM_MODELS > custom deletion, addition, and renaming of models 1`] = `
+[
+  {
+    "displayName": "llama",
+    "name": "llama",
+  },
+  {
+    "displayName": "claude-2",
+    "name": "claude-2",
+  },
+  {
+    "displayName": "gpt-4-32k",
+    "name": "gpt-4-1106-preview",
+  },
+]
+`;
+
+exports[`modelProviderSelectors > CUSTOM_MODELS > duplicate naming model 1`] = `
+[
+  {
+    "displayName": "gpt-3.5-turbo",
+    "name": "gpt-3.5-turbo",
+  },
+  {
+    "displayName": "gpt-3.5-turbo-1106",
+    "name": "gpt-3.5-turbo-1106",
+  },
+  {
+    "displayName": "gpt-3.5-turbo-16k",
+    "name": "gpt-3.5-turbo-16k",
+  },
+  {
+    "displayName": "gpt-4",
+    "name": "gpt-4",
+  },
+  {
+    "displayName": "gpt-4-32k",
+    "name": "gpt-4-32k",
+  },
+  {
+    "displayName": "gpt-4-vision-preview",
+    "name": "gpt-4-vision-preview",
+  },
+  {
+    "displayName": "gpt-4-32k",
+    "name": "gpt-4-1106-preview",
+  },
+]
+`;
+
+exports[`modelProviderSelectors > CUSTOM_MODELS > only add the model 1`] = `
+[
+  {
+    "displayName": "gpt-3.5-turbo",
+    "name": "gpt-3.5-turbo",
+  },
+  {
+    "displayName": "gpt-3.5-turbo-1106",
+    "name": "gpt-3.5-turbo-1106",
+  },
+  {
+    "displayName": "gpt-3.5-turbo-16k",
+    "name": "gpt-3.5-turbo-16k",
+  },
+  {
+    "displayName": "gpt-4",
+    "name": "gpt-4",
+  },
+  {
+    "displayName": "gpt-4-32k",
+    "name": "gpt-4-32k",
+  },
+  {
+    "displayName": "gpt-4-1106-preview",
+    "name": "gpt-4-1106-preview",
+  },
+  {
+    "displayName": "gpt-4-vision-preview",
+    "name": "gpt-4-vision-preview",
+  },
+  {
+    "displayName": "model1",
+    "name": "model1",
+  },
+  {
+    "displayName": "model2",
+    "name": "model2",
+  },
+  {
+    "displayName": "model3",
+    "name": "model3",
+  },
+  {
+    "displayName": "model4",
+    "name": "model4",
+  },
+]
+`;

package/src/store/global/slices/settings/selectors/__snapshots__/selectors.test.ts.snap

@@ -0,0 +1,132 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`settingsSelectors > currentSettings > should merge DEFAULT_SETTINGS and s.settings correctly 1`] = `
+{
+  "avatar": "avatar.jpg",
+  "defaultAgent": {
+    "config": {
+      "model": "gpt-3.5-turbo",
+      "params": {},
+      "systemRole": "",
+      "tts": {
+        "showAllLocaleVoice": false,
+        "sttLocale": "auto",
+        "ttsService": "openai",
+        "voice": {
+          "openai": "alloy",
+        },
+      },
+    },
+    "meta": {
+      "avatar": "Default Agent",
+      "description": "Default agent for testing",
+    },
+  },
+  "fontSize": 14,
+  "language": "en-US",
+  "languageModel": {
+    "openAI": {
+      "OPENAI_API_KEY": "openai-api-key",
+      "endpoint": "https://openai-endpoint.com",
+      "models": [
+        "gpt-3.5-turbo",
+      ],
+    },
+  },
+  "neutralColor": "sand",
+  "password": "password123",
+  "primaryColor": "blue",
+  "themeMode": "light",
+  "tts": {
+    "openAI": {
+      "sttModel": "whisper-1",
+      "ttsModel": "tts-1",
+    },
+    "sttAutoStop": true,
+    "sttServer": "openai",
+  },
+}
+`;
+
+exports[`settingsSelectors > currentTTS > should merge DEFAULT_TTS_CONFIG and s.settings.tts correctly 1`] = `
+{
+  "openAI": {
+    "sttModel": "whisper-2",
+    "ttsModel": "tts-1",
+  },
+  "sttAutoStop": false,
+  "sttServer": "openai",
+}
+`;
+
+exports[`settingsSelectors > dalleConfig > should return the dalle configuration 1`] = `
+{
+  "apiKey": "dalle-api-key",
+  "autoGenerate": true,
+}
+`;
+
+exports[`settingsSelectors > defaultAgent > should merge DEFAULT_AGENT and s.settings.defaultAgent correctly 1`] = `
+{
+  "config": {
+    "autoCreateTopicThreshold": 2,
+    "displayMode": "chat",
+    "enableAutoCreateTopic": true,
+    "historyCount": 1,
+    "model": "gpt-3.5-turbo",
+    "params": {
+      "frequency_penalty": 0,
+      "presence_penalty": 0,
+      "temperature": 0.6,
+      "top_p": 1,
+    },
+    "plugins": [],
+    "systemRole": "user",
+    "tts": {
+      "showAllLocaleVoice": false,
+      "sttLocale": "auto",
+      "ttsService": "openai",
+      "voice": {
+        "openai": "alloy",
+      },
+    },
+  },
+  "meta": {
+    "avatar": "agent-avatar.jpg",
+    "description": "Test agent",
+  },
+}
+`;
+
+exports[`settingsSelectors > defaultAgentConfig > should merge DEFAULT_AGENT_CONFIG and defaultAgent(s).config correctly 1`] = `
+{
+  "autoCreateTopicThreshold": 2,
+  "displayMode": "chat",
+  "enableAutoCreateTopic": true,
+  "historyCount": 1,
+  "model": "gpt-3.5-turbo",
+  "params": {
+    "frequency_penalty": 0,
+    "presence_penalty": 0,
+    "temperature": 0.7,
+    "top_p": 1,
+  },
+  "plugins": [],
+  "systemRole": "user",
+  "tts": {
+    "showAllLocaleVoice": false,
+    "sttLocale": "auto",
+    "ttsService": "openai",
+    "voice": {
+      "openai": "alloy",
+    },
+  },
+}
+`;
+
+exports[`settingsSelectors > defaultAgentMeta > should merge DEFAULT_AGENT_META and defaultAgent(s).meta correctly 1`] = `
+{
+  "avatar": "agent-avatar.jpg",
+  "description": "Test agent",
+}
+`;

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

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

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

@@ -0,0 +1,100 @@
+import { GlobalStore } from '../../../store';
+import { modelProviderSelectors } from './modelProvider';
+
+describe('modelProviderSelectors', () => {
+  describe('CUSTOM_MODELS', () => {
+    it('custom deletion, addition, and renaming of models', () => {
+      const s = {
+        serverConfig: {
+          customModelName:
+            '-all,+llama,+claude-2，-gpt-3.5-turbo,gpt-4-1106-preview=gpt-4-turbo,gpt-4-1106-preview=gpt-4-32k',
+        },
+        settings: {
+          languageModel: {
+            openAI: {},
+          },
+        },
+      } as unknown as GlobalStore;
+
+      const result = modelProviderSelectors.modelList(s);
+
+      expect(result).toMatchSnapshot();
+    });
+
+    it('duplicate naming model', () => {
+      const s = {
+        serverConfig: {},
+        settings: {
+          languageModel: {
+            openAI: {
+              customModelName: 'gpt-4-1106-preview=gpt-4-turbo，gpt-4-1106-preview=gpt-4-32k',
+            },
+          },
+        },
+      } as unknown as GlobalStore;
+
+      const result = modelProviderSelectors.modelList(s);
+
+      expect(result).toMatchSnapshot();
+    });
+
+    it('should delete model', () => {
+      const s = {
+        serverConfig: {
+          customModelName: '-gpt-4',
+        },
+        settings: {
+          languageModel: {
+            openAI: {},
+          },
+        },
+      } as unknown as GlobalStore;
+
+      const result = modelProviderSelectors.modelList(s);
+
+      expect(result).toEqual([
+        {
+          displayName: 'gpt-3.5-turbo',
+          name: 'gpt-3.5-turbo',
+        },
+        {
+          displayName: 'gpt-3.5-turbo-1106',
+          name: 'gpt-3.5-turbo-1106',
+        },
+        {
+          displayName: 'gpt-3.5-turbo-16k',
+          name: 'gpt-3.5-turbo-16k',
+        },
+        {
+          displayName: 'gpt-4-32k',
+          name: 'gpt-4-32k',
+        },
+        {
+          displayName: 'gpt-4-1106-preview',
+          name: 'gpt-4-1106-preview',
+        },
+        {
+          displayName: 'gpt-4-vision-preview',
+          name: 'gpt-4-vision-preview',
+        },
+      ]);
+    });
+
+    it('only add the model', () => {
+      const s = {
+        serverConfig: {},
+        settings: {
+          languageModel: {
+            openAI: {
+              customModelName: 'model1,model2,model3，model4',
+            },
+          },
+        },
+      } as unknown as GlobalStore;
+
+      const result = modelProviderSelectors.modelList(s);
+
+      expect(result).toMatchSnapshot();
+    });
+  });
+});