@lobehub/chat 0.146.1 → 0.147.0

package/src/services/_auth.ts

@@ -1,25 +1,13 @@
 import { JWTPayload, LOBE_CHAT_AUTH_HEADER } from '@/const/auth';
 import { ModelProvider } from '@/libs/agent-runtime';
 import { useGlobalStore } from '@/store/global';
-import { modelProviderSelectors, settingsSelectors } from '@/store/global/selectors';
+import { modelConfigSelectors, settingsSelectors } from '@/store/global/selectors';
 import { createJWT } from '@/utils/jwt';
 
 export const getProviderAuthPayload = (provider: string) => {
   switch (provider) {
-    case ModelProvider.ZhiPu: {
-      return { apiKey: modelProviderSelectors.zhipuAPIKey(useGlobalStore.getState()) };
-    }
-
-    case ModelProvider.Moonshot: {
-      return { apiKey: modelProviderSelectors.moonshotAPIKey(useGlobalStore.getState()) };
-    }
-
-    case ModelProvider.Google: {
-      return { apiKey: modelProviderSelectors.googleAPIKey(useGlobalStore.getState()) };
-    }
-
     case ModelProvider.Bedrock: {
-      const { accessKeyId, region, secretAccessKey } = modelProviderSelectors.bedrockConfig(
+      const { accessKeyId, region, secretAccessKey } = modelConfigSelectors.bedrockConfig(
         useGlobalStore.getState(),
       );
       const awsSecretAccessKey = secretAccessKey;
@@ -31,7 +19,7 @@ export const getProviderAuthPayload = (provider: string) => {
     }
 
     case ModelProvider.Azure: {
-      const azure = modelProviderSelectors.azureConfig(useGlobalStore.getState());
+      const azure = modelConfigSelectors.azureConfig(useGlobalStore.getState());
 
       return {
         apiKey: azure.apiKey,
@@ -41,55 +29,15 @@ export const getProviderAuthPayload = (provider: string) => {
     }
 
     case ModelProvider.Ollama: {
-      const endpoint = modelProviderSelectors.ollamaProxyUrl(useGlobalStore.getState());
-
-      return {
-        endpoint,
-      };
-    }
-
-    case ModelProvider.Perplexity: {
-      return { apiKey: modelProviderSelectors.perplexityAPIKey(useGlobalStore.getState()) };
-    }
+      const endpoint = modelConfigSelectors.ollamaProxyUrl(useGlobalStore.getState());
 
-    case ModelProvider.Anthropic: {
-      const apiKey = modelProviderSelectors.anthropicAPIKey(useGlobalStore.getState());
-      const endpoint = modelProviderSelectors.anthropicProxyUrl(useGlobalStore.getState());
-      return { apiKey, endpoint };
+      return { endpoint };
     }
 
-    case ModelProvider.Mistral: {
-      return { apiKey: modelProviderSelectors.mistralAPIKey(useGlobalStore.getState()) };
-    }
-
-    case ModelProvider.Groq: {
-      return { apiKey: modelProviderSelectors.groqAPIKey(useGlobalStore.getState()) };
-    }
-
-    case ModelProvider.OpenRouter: {
-      return { apiKey: modelProviderSelectors.openrouterAPIKey(useGlobalStore.getState()) };
-    }
-
-    case ModelProvider.TogetherAI: {
-      return { apiKey: modelProviderSelectors.togetheraiAPIKey(useGlobalStore.getState()) };
-    }
-
-    case ModelProvider.ZeroOne: {
-      return { apiKey: modelProviderSelectors.zerooneAPIKey(useGlobalStore.getState()) };
-    }
+    default: {
+      const config = modelConfigSelectors.providerConfig(provider)(useGlobalStore.getState());
 
-    default:
-    case ModelProvider.OpenAI: {
-      const openai = modelProviderSelectors.openAIConfig(useGlobalStore.getState());
-      const apiKey = openai.OPENAI_API_KEY || '';
-      const endpoint = openai.endpoint || '';
-
-      return {
-        apiKey,
-        azureApiVersion: openai.azureApiVersion,
-        endpoint,
-        useAzure: openai.useAzure,
-      };
+      return { apiKey: config?.apiKey, endpoint: config?.endpoint };
     }
   }
 };

package/src/services/_header.ts

@@ -1,12 +1,6 @@
-import {
-  AZURE_OPENAI_API_VERSION,
-  LOBE_CHAT_ACCESS_CODE,
-  OPENAI_API_KEY_HEADER_KEY,
-  OPENAI_END_POINT,
-  USE_AZURE_OPENAI,
-} from '@/const/fetch';
+import { LOBE_CHAT_ACCESS_CODE, OPENAI_API_KEY_HEADER_KEY, OPENAI_END_POINT } from '@/const/fetch';
 import { useGlobalStore } from '@/store/global';
-import { modelProviderSelectors, settingsSelectors } from '@/store/global/selectors';
+import { modelConfigSelectors, settingsSelectors } from '@/store/global/selectors';
 
 /**
  * TODO: Need to be removed after tts refactor
@@ -14,25 +8,14 @@ import { modelProviderSelectors, settingsSelectors } from '@/store/global/select
  */
 // eslint-disable-next-line no-undef
 export const createHeaderWithOpenAI = (header?: HeadersInit): HeadersInit => {
-  const openai = modelProviderSelectors.openAIConfig(useGlobalStore.getState());
-
-  const apiKey = openai.OPENAI_API_KEY || '';
-  const endpoint = openai.endpoint || '';
+  const apiKey = modelConfigSelectors.openAIAPIKey(useGlobalStore.getState()) || '';
+  const endpoint = modelConfigSelectors.openAIProxyUrl(useGlobalStore.getState()) || '';
 
   // eslint-disable-next-line no-undef
-  const result: HeadersInit = {
+  return {
     ...header,
     [LOBE_CHAT_ACCESS_CODE]: settingsSelectors.password(useGlobalStore.getState()),
     [OPENAI_API_KEY_HEADER_KEY]: apiKey,
     [OPENAI_END_POINT]: endpoint,
   };
-
-  if (openai.useAzure) {
-    Object.assign(result, {
-      [AZURE_OPENAI_API_VERSION]: openai.azureApiVersion || '',
-      [USE_AZURE_OPENAI]: '1',
-    });
-  }
-
-  return result;
 };

package/src/services/_url.ts

@@ -29,6 +29,7 @@ export const API_ENDPOINTS = mapWithBasePath({
 
   // chat
   chat: (provider: string) => withBasePath(`/api/chat/${provider}`),
+  chatModels: (provider: string) => withBasePath(`/api/chat/models/${provider}`),
 
   // trace
   trace: '/api/trace',

package/src/services/chat.ts

@@ -9,6 +9,7 @@ import { filesSelectors, useFileStore } from '@/store/file';
 import { useGlobalStore } from '@/store/global';
 import {
   commonSelectors,
+  modelConfigSelectors,
   modelProviderSelectors,
   preferenceSelectors,
 } from '@/store/global/selectors';
@@ -131,13 +132,22 @@ class ChatService {
     const { signal } = options ?? {};
 
     const { provider = ModelProvider.OpenAI, ...res } = params;
+
+    let model = res.model || DEFAULT_AGENT_CONFIG.model;
+
+    // if the provider is Azure, get the deployment name as the request model
+    if (provider === ModelProvider.Azure) {
+      const chatModelCards = modelConfigSelectors.providerModelCards(provider)(
+        useGlobalStore.getState(),
+      );
+
+      const deploymentName = chatModelCards.find((i) => i.id === model)?.deploymentName;
+      if (deploymentName) model = deploymentName;
+    }
+
     const payload = merge(
-      {
-        model: DEFAULT_AGENT_CONFIG.model,
-        stream: true,
-        ...DEFAULT_AGENT_CONFIG.params,
-      },
-      res,
+      { model: DEFAULT_AGENT_CONFIG.model, stream: true, ...DEFAULT_AGENT_CONFIG.params },
+      { ...res, model },
     );
 
     const traceHeader = createTraceHeader({ ...options?.trace });

package/src/services/global.ts

@@ -1,5 +1,5 @@
 import { dataSync } from '@/database/core';
-import { GlobalServerConfig } from '@/types/settings';
+import { GlobalServerConfig } from '@/types/serverConfig';
 import { StartDataSyncParams } from '@/types/sync';
 
 import { API_ENDPOINTS } from './_url';

package/src/services/models.ts

@@ -0,0 +1,23 @@
+import { createHeaderWithAuth } from '@/services/_auth';
+import { ChatModelCard } from '@/types/llm';
+
+import { API_ENDPOINTS } from './_url';
+
+class ModelsService {
+  getChatModels = async (provider: string): Promise<ChatModelCard[] | undefined> => {
+    const headers = await createHeaderWithAuth({
+      headers: { 'Content-Type': 'application/json' },
+      provider,
+    });
+    try {
+      const res = await fetch(API_ENDPOINTS.chatModels(provider), { headers });
+      if (!res.ok) return;
+
+      return res.json();
+    } catch {
+      return;
+    }
+  };
+}
+
+export const modelsService = new ModelsService();

package/src/services/ollama.ts

@@ -3,7 +3,7 @@ import { ListResponse, Ollama as OllamaBrowser, ProgressResponse } from 'ollama/
 import { createErrorResponse } from '@/app/api/errorResponse';
 import { ModelProvider } from '@/libs/agent-runtime';
 import { useGlobalStore } from '@/store/global';
-import { modelProviderSelectors } from '@/store/global/selectors';
+import { modelConfigSelectors } from '@/store/global/selectors';
 import { ChatErrorType } from '@/types/fetch';
 import { getMessageError } from '@/utils/fetch';
 
@@ -11,7 +11,7 @@ const DEFAULT_BASE_URL = 'http://127.0.0.1:11434/v1';
 
 class OllamaService {
   getHost = (): string => {
-    const endpoint = modelProviderSelectors.ollamaProxyUrl(useGlobalStore.getState());
+    const endpoint = modelConfigSelectors.ollamaProxyUrl(useGlobalStore.getState());
     const url = new URL(endpoint || DEFAULT_BASE_URL);
     return url.host;
   };

package/src/store/chat/slices/share/action.test.ts

@@ -3,6 +3,7 @@ import { act, renderHook } from '@testing-library/react';
 import { DEFAULT_USER_AVATAR_URL } from '@/const/meta';
 import { shareGPTService } from '@/services/share';
 import { useChatStore } from '@/store/chat';
+import { ChatMessage } from '@/types/message';
 
 describe('shareSlice actions', () => {
   let shareGPTServiceSpy: any;
@@ -82,5 +83,117 @@ describe('shareSlice actions', () => {
       expect(result.current.shareLoading).toBe(false);
       // 注意：这里的验证可能需要你根据实际的状态管理逻辑进行调整
     });
+
+    it('should include plugin information when withPluginInfo is true', async () => {
+      // 模拟带有插件信息的消息
+      const pluginMessage = {
+        role: 'function',
+        content: 'plugin content',
+        plugin: {
+          type: 'default',
+          arguments: '{}',
+          apiName: 'test-api',
+          identifier: 'test-identifier',
+        },
+        id: 'abc',
+      } as ChatMessage;
+
+      act(() => {
+        useChatStore.setState({ messages: [pluginMessage] });
+      });
+
+      const { result } = renderHook(() => useChatStore());
+      await act(async () => {
+        result.current.shareToShareGPT({ withPluginInfo: true });
+      });
+      expect(shareGPTServiceSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          items: expect.arrayContaining([
+            expect.objectContaining({
+              from: 'gpt',
+              value: expect.stringContaining('Function Calling Plugin'),
+            }),
+          ]),
+        }),
+      );
+    });
+
+    it('should not include plugin information when withPluginInfo is false', async () => {
+      const pluginMessage = {
+        role: 'function',
+        content: 'plugin content',
+        plugin: {
+          type: 'default',
+          arguments: '{}',
+          apiName: 'test-api',
+          identifier: 'test-identifier',
+        },
+        id: 'abc',
+      } as ChatMessage;
+
+      act(() => {
+        useChatStore.setState({ messages: [pluginMessage] });
+      });
+
+      const { result } = renderHook(() => useChatStore());
+      await act(async () => {
+        result.current.shareToShareGPT({ withPluginInfo: false });
+      });
+      expect(shareGPTServiceSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          items: expect.not.arrayContaining([
+            expect.objectContaining({
+              from: 'gpt',
+              value: expect.stringContaining('Function Calling Plugin'),
+            }),
+          ]),
+        }),
+      );
+    });
+
+    it('should handle messages from different roles correctly', async () => {
+      const messages = [
+        { role: 'user', content: 'user message', id: '1' },
+        { role: 'assistant', content: 'assistant message', id: '2' },
+        {
+          role: 'function',
+          content: 'plugin content',
+          plugin: {
+            type: 'default',
+            arguments: '{}',
+            apiName: 'test-api',
+            identifier: 'test-identifier',
+          },
+          id: '3',
+        },
+      ] as ChatMessage[];
+
+      act(() => {
+        useChatStore.setState({ messages });
+      });
+
+      const { result } = renderHook(() => useChatStore());
+      await act(async () => {
+        await result.current.shareToShareGPT({
+          withPluginInfo: true,
+          withSystemRole: true,
+        });
+      });
+
+      expect(shareGPTServiceSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          items: [
+            expect.objectContaining({ from: 'gpt' }), // Agent meta info
+            expect.objectContaining({ from: 'human', value: 'user message' }),
+            expect.objectContaining({ from: 'gpt', value: 'assistant message' }),
+            expect.objectContaining({
+              from: 'gpt',
+              value: expect.stringContaining('Function Calling Plugin'),
+            }),
+            expect.objectContaining({ from: 'gpt', value: expect.stringContaining('Share from') }), // Footer
+          ],
+        }),
+      );
+    });
   });
 });

package/src/store/chat/slices/share/action.ts

@@ -47,7 +47,7 @@ export interface ShareAction {
     avatar?: string;
     withPluginInfo?: boolean;
     withSystemRole?: boolean;
-  }) => void;
+  }) => Promise<void>;
 }
 
 export const chatShare: StateCreator<ChatStore, [['zustand/devtools', never]], [], ShareAction> = (

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

@@ -4,9 +4,13 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 import { withSWR } from '~test-utils';
 
 import { globalService } from '@/services/global';
+import { messageService } from '@/services/message';
 import { userService } from '@/services/user';
 import { useGlobalStore } from '@/store/global';
-import { GlobalServerConfig } from '@/types/settings';
+import { commonSelectors } from '@/store/global/slices/common/selectors';
+import { preferenceSelectors } from '@/store/global/slices/preference/selectors';
+import { syncSettingsSelectors } from '@/store/global/slices/settings/selectors';
+import { GlobalServerConfig } from '@/types/serverConfig';
 import { switchLang } from '@/utils/client/switchLang';
 
 vi.mock('zustand/traditional');
@@ -200,4 +204,165 @@ describe('createCommonSlice', () => {
       expect(useGlobalStore.getState().settings).toEqual({});
     });
   });
+
+  describe('refreshConnection', () => {
+    it('should not call triggerEnableSync when userId is empty', async () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const onEvent = vi.fn();
+
+      vi.spyOn(commonSelectors, 'userId').mockReturnValueOnce(undefined);
+      const triggerEnableSyncSpy = vi.spyOn(result.current, 'triggerEnableSync');
+
+      await act(async () => {
+        await result.current.refreshConnection(onEvent);
+      });
+
+      expect(triggerEnableSyncSpy).not.toHaveBeenCalled();
+    });
+
+    it('should call triggerEnableSync when userId exists', async () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const onEvent = vi.fn();
+      const userId = 'user-id';
+
+      vi.spyOn(commonSelectors, 'userId').mockReturnValueOnce(userId);
+      const triggerEnableSyncSpy = vi.spyOn(result.current, 'triggerEnableSync');
+
+      await act(async () => {
+        await result.current.refreshConnection(onEvent);
+      });
+
+      expect(triggerEnableSyncSpy).toHaveBeenCalledWith(userId, onEvent);
+    });
+  });
+
+  describe('triggerEnableSync', () => {
+    it('should return false when sync.channelName is empty', async () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const userId = 'user-id';
+      const onEvent = vi.fn();
+
+      vi.spyOn(syncSettingsSelectors, 'webrtcConfig').mockReturnValueOnce({
+        channelName: '',
+        enabled: true,
+      });
+
+      const data = await act(async () => {
+        return result.current.triggerEnableSync(userId, onEvent);
+      });
+
+      expect(data).toBe(false);
+    });
+
+    it('should call globalService.enabledSync when sync.channelName exists', async () => {
+      const userId = 'user-id';
+      const onEvent = vi.fn();
+      const channelName = 'channel-name';
+      const channelPassword = 'channel-password';
+      const deviceName = 'device-name';
+      const signaling = 'signaling';
+
+      vi.spyOn(syncSettingsSelectors, 'webrtcConfig').mockReturnValueOnce({
+        channelName,
+        channelPassword,
+        signaling,
+        enabled: true,
+      });
+      vi.spyOn(syncSettingsSelectors, 'deviceName').mockReturnValueOnce(deviceName);
+      const enabledSyncSpy = vi.spyOn(globalService, 'enabledSync').mockResolvedValueOnce(true);
+      const { result } = renderHook(() => useGlobalStore());
+
+      const data = await act(async () => {
+        return result.current.triggerEnableSync(userId, onEvent);
+      });
+
+      expect(enabledSyncSpy).toHaveBeenCalledWith({
+        channel: { name: channelName, password: channelPassword },
+        onAwarenessChange: expect.any(Function),
+        onSyncEvent: onEvent,
+        onSyncStatusChange: expect.any(Function),
+        signaling,
+        user: expect.objectContaining({ id: userId, name: deviceName }),
+      });
+      expect(data).toBe(true);
+    });
+  });
+
+  describe('useCheckTrace', () => {
+    it('should return false when shouldFetch is false', async () => {
+      const { result } = renderHook(() => useGlobalStore().useCheckTrace(false), {
+        wrapper: withSWR,
+      });
+
+      await waitFor(() => expect(result.current.data).toBe(false));
+    });
+
+    it('should return false when userAllowTrace is already set', async () => {
+      vi.spyOn(preferenceSelectors, 'userAllowTrace').mockReturnValueOnce(true);
+
+      const { result } = renderHook(() => useGlobalStore().useCheckTrace(true), {
+        wrapper: withSWR,
+      });
+
+      await waitFor(() => expect(result.current.data).toBe(false));
+    });
+
+    it('should call messageService.messageCountToCheckTrace when needed', async () => {
+      vi.spyOn(preferenceSelectors, 'userAllowTrace').mockReturnValueOnce(null);
+      const messageCountToCheckTraceSpy = vi
+        .spyOn(messageService, 'messageCountToCheckTrace')
+        .mockResolvedValueOnce(true);
+
+      const { result } = renderHook(() => useGlobalStore().useCheckTrace(true), {
+        wrapper: withSWR,
+      });
+
+      await waitFor(() => expect(result.current.data).toBe(true));
+      expect(messageCountToCheckTraceSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('useEnabledSync', () => {
+    it('should return false when userId is empty', async () => {
+      const { result } = renderHook(
+        () => useGlobalStore().useEnabledSync(true, undefined, vi.fn()),
+        { wrapper: withSWR },
+      );
+
+      await waitFor(() => expect(result.current.data).toBe(false));
+    });
+
+    it('should call globalService.disableSync when userEnableSync is false', async () => {
+      const disableSyncSpy = vi.spyOn(globalService, 'disableSync').mockResolvedValueOnce(false);
+
+      const { result } = renderHook(
+        () => useGlobalStore().useEnabledSync(false, 'user-id', vi.fn()),
+        { wrapper: withSWR },
+      );
+
+      await waitFor(() => expect(result.current.data).toBeUndefined());
+      expect(disableSyncSpy).toHaveBeenCalled();
+    });
+
+    it('should call triggerEnableSync when userEnableSync and userId exist', async () => {
+      const userId = 'user-id';
+      const onEvent = vi.fn();
+      const triggerEnableSyncSpy = vi.fn().mockResolvedValueOnce(true);
+
+      const { result } = renderHook(() => useGlobalStore());
+
+      // replace triggerEnableSync as a mock
+      result.current.triggerEnableSync = triggerEnableSyncSpy;
+
+      const { result: swrResult } = renderHook(
+        () => result.current.useEnabledSync(true, userId, onEvent),
+        {
+          wrapper: withSWR,
+        },
+      );
+
+      await waitFor(() => expect(swrResult.current.data).toBe(true));
+      expect(triggerEnableSyncSpy).toHaveBeenCalledWith(userId, onEvent);
+    });
+  });
 });

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

@@ -10,7 +10,8 @@ import { globalService } from '@/services/global';
 import { messageService } from '@/services/message';
 import { UserConfig, userService } from '@/services/user';
 import type { GlobalStore } from '@/store/global';
-import type { GlobalServerConfig, GlobalSettings } from '@/types/settings';
+import type { GlobalServerConfig } from '@/types/serverConfig';
+import type { GlobalSettings } from '@/types/settings';
 import { OnSyncEvent, PeerSyncStatus } from '@/types/sync';
 import { switchLang } from '@/utils/client/switchLang';
 import { merge } from '@/utils/merge';

package/src/store/global/slices/settings/{action.test.ts → actions/general.test.ts}

@@ -7,7 +7,7 @@ import { DEFAULT_AGENT, DEFAULT_SETTINGS } from '@/const/settings';
 import { userService } from '@/services/user';
 import { useGlobalStore } from '@/store/global';
 import { LobeAgentSettings } from '@/types/session';
-import { GlobalSettings, OpenAIConfig } from '@/types/settings';
+import { GlobalSettings } from '@/types/settings';
 
 // Mock userService
 vi.mock('@/services/user', () => ({
@@ -66,24 +66,6 @@ describe('SettingsAction', () => {
     });
   });
 
-  describe('setModelProviderConfig', () => {
-    it('should set OpenAI configuration', async () => {
-      const { result } = renderHook(() => useGlobalStore());
-      const openAIConfig: Partial<OpenAIConfig> = { OPENAI_API_KEY: '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('setSettings', () => {
     it('should set partial settings', async () => {
       const { result } = renderHook(() => useGlobalStore());

package/src/store/global/slices/settings/{action.ts → actions/general.ts}

@@ -6,31 +6,23 @@ import type { StateCreator } from 'zustand/vanilla';
 import { userService } from '@/services/user';
 import type { GlobalStore } from '@/store/global';
 import { LobeAgentSettings } from '@/types/session';
-import { GlobalLLMConfig, GlobalLLMProviderKey, GlobalSettings } from '@/types/settings';
+import { GlobalSettings } from '@/types/settings';
 import { difference } from '@/utils/difference';
 import { merge } from '@/utils/merge';
 
-/**
- * 设置操作
- */
-export interface SettingsAction {
+export interface GeneralSettingsAction {
   importAppSettings: (settings: GlobalSettings) => Promise<void>;
   resetSettings: () => Promise<void>;
-  setModelProviderConfig: <T extends GlobalLLMProviderKey>(
-    provider: T,
-    config: Partial<GlobalLLMConfig[T]>,
-  ) => Promise<void>;
   setSettings: (settings: DeepPartial<GlobalSettings>) => Promise<void>;
   switchThemeMode: (themeMode: ThemeMode) => Promise<void>;
-  toggleProviderEnabled: (provider: GlobalLLMProviderKey, enabled: boolean) => Promise<void>;
   updateDefaultAgent: (agent: DeepPartial<LobeAgentSettings>) => Promise<void>;
 }
 
-export const createSettingsSlice: StateCreator<
+export const generalSettingsSlice: StateCreator<
   GlobalStore,
   [['zustand/devtools', never]],
   [],
-  SettingsAction
+  GeneralSettingsAction
 > = (set, get) => ({
   importAppSettings: async (importAppSettings) => {
     const { setSettings } = get();
@@ -43,9 +35,6 @@ export const createSettingsSlice: StateCreator<
     await userService.resetUserSettings();
     await get().refreshUserConfig();
   },
-  setModelProviderConfig: async (provider, config) => {
-    await get().setSettings({ languageModel: { [provider]: config } });
-  },
   setSettings: async (settings) => {
     const { settings: prevSetting, defaultSettings } = get();
 
@@ -58,13 +47,9 @@ export const createSettingsSlice: StateCreator<
     await userService.updateUserSettings(diffs);
     await get().refreshUserConfig();
   },
-
   switchThemeMode: async (themeMode) => {
     await get().setSettings({ themeMode });
   },
-  toggleProviderEnabled: async (provider, enabled) => {
-    await get().setSettings({ languageModel: { [provider]: { enabled } } });
-  },
   updateDefaultAgent: async (defaultAgent) => {
     await get().setSettings({ defaultAgent });
   },

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

@@ -0,0 +1,18 @@
+import type { StateCreator } from 'zustand/vanilla';
+
+import type { GlobalStore } from '@/store/global';
+
+import { GeneralSettingsAction, generalSettingsSlice } from './general';
+import { LLMSettingsAction, llmSettingsSlice } from './llm';
+
+export interface SettingsAction extends LLMSettingsAction, GeneralSettingsAction {}
+
+export const createSettingsSlice: StateCreator<
+  GlobalStore,
+  [['zustand/devtools', never]],
+  [],
+  SettingsAction
+> = (...params) => ({
+  ...llmSettingsSlice(...params),
+  ...generalSettingsSlice(...params),
+});