@lobehub/chat 0.146.2 → 0.147.1

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

@@ -1,203 +1,119 @@
-import { produce } from 'immer';
-
 import {
-  AnthropicProvider,
-  BedrockProvider,
-  GoogleProvider,
-  GroqProvider,
-  LOBE_DEFAULT_MODEL_LIST,
-  MistralProvider,
-  MoonshotProvider,
-  OllamaProvider,
-  OpenAIProvider,
-  OpenRouterProvider,
-  PerplexityProvider,
-  TogetherAIProvider,
-  ZeroOneProvider,
-  ZhiPuProvider,
+  AnthropicProviderCard,
+  AzureProviderCard,
+  BedrockProviderCard,
+  GoogleProviderCard,
+  GroqProviderCard,
+  MistralProviderCard,
+  MoonshotProviderCard,
+  OllamaProviderCard,
+  OpenAIProviderCard,
+  OpenRouterProviderCard,
+  PerplexityProviderCard,
+  TogetherAIProviderCard,
+  ZeroOneProviderCard,
+  ZhiPuProviderCard,
+  filterEnabledModels,
 } from '@/config/modelProviders';
 import { ChatModelCard, ModelProviderCard } from '@/types/llm';
+import { ServerModelProviderConfig } from '@/types/serverConfig';
 import { GlobalLLMProviderKey } from '@/types/settings';
-import { parseModelString } from '@/utils/parseModels';
 
 import { GlobalStore } from '../../../store';
 import { currentSettings } from './settings';
 
-const modelProvider = (s: GlobalStore) => currentSettings(s).languageModel;
-const providerEnabled = (provider: GlobalLLMProviderKey) => (s: GlobalStore) =>
-  currentSettings(s).languageModel[provider]?.enabled || false;
-
-const openAIConfig = (s: GlobalStore) => modelProvider(s).openAI;
-
-const openAIAPIKey = (s: GlobalStore) => openAIConfig(s).OPENAI_API_KEY;
-const openAIProxyUrl = (s: GlobalStore) => openAIConfig(s).endpoint;
-
-const enableZhipu = (s: GlobalStore) => modelProvider(s).zhipu.enabled;
-const zhipuAPIKey = (s: GlobalStore) => modelProvider(s).zhipu.apiKey;
-const zhipuProxyUrl = (s: GlobalStore) => modelProvider(s).zhipu.endpoint;
-
-const enableBedrock = (s: GlobalStore) => modelProvider(s).bedrock.enabled;
-const bedrockConfig = (s: GlobalStore) => modelProvider(s).bedrock;
-
-const enableGoogle = (s: GlobalStore) => modelProvider(s).google.enabled;
-const googleAPIKey = (s: GlobalStore) => modelProvider(s).google.apiKey;
-const googleProxyUrl = (s: GlobalStore) => modelProvider(s).google.endpoint;
-
-const enableAzure = (s: GlobalStore) => modelProvider(s).openAI.useAzure;
-const azureConfig = (s: GlobalStore) => modelProvider(s).azure;
-
-const enableMistral = (s: GlobalStore) => modelProvider(s).mistral.enabled;
-const mistralAPIKey = (s: GlobalStore) => modelProvider(s).mistral.apiKey;
-
-const enableMoonshot = (s: GlobalStore) => modelProvider(s).moonshot.enabled;
-const moonshotAPIKey = (s: GlobalStore) => modelProvider(s).moonshot.apiKey;
-
-const enableOllama = (s: GlobalStore) => modelProvider(s).ollama.enabled;
-const ollamaProxyUrl = (s: GlobalStore) => modelProvider(s).ollama.endpoint;
-
-const enablePerplexity = (s: GlobalStore) => modelProvider(s).perplexity.enabled;
-const perplexityAPIKey = (s: GlobalStore) => modelProvider(s).perplexity.apiKey;
-
-const enableAnthropic = (s: GlobalStore) => modelProvider(s).anthropic.enabled;
-const anthropicAPIKey = (s: GlobalStore) => modelProvider(s).anthropic.apiKey;
-const anthropicProxyUrl = (s: GlobalStore) => modelProvider(s).anthropic.endpoint;
-
-const enableGroq = (s: GlobalStore) => modelProvider(s).groq.enabled;
-const groqAPIKey = (s: GlobalStore) => modelProvider(s).groq.apiKey;
+/**
+ * get the server side model cards
+ */
+const serverProviderModelCards =
+  (provider: GlobalLLMProviderKey) =>
+  (s: GlobalStore): ChatModelCard[] | undefined => {
+    const config = s.serverConfig.languageModel?.[provider] as
+      | ServerModelProviderConfig
+      | undefined;
+
+    if (!config) return;
+
+    return config.serverModelCards;
+  };
+
+const remoteProviderModelCards =
+  (provider: GlobalLLMProviderKey) =>
+  (s: GlobalStore): ChatModelCard[] | undefined => {
+    const cards = currentSettings(s).languageModel?.[provider]?.remoteModelCards as
+      | ChatModelCard[]
+      | undefined;
+
+    if (!cards) return;
+
+    return cards;
+  };
+
+/**
+ * define all the model list of providers
+ */
+const providerModelList = (s: GlobalStore): ModelProviderCard[] => {
+  /**
+   * 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 = (provider: GlobalLLMProviderKey, defaultChatModels: ChatModelCard[]) => {
+    // if the chat model is config in the server side, use the server side model cards
+    const serverChatModels = serverProviderModelCards(provider)(s);
+    const remoteChatModels = remoteProviderModelCards(provider)(s);
+
+    return serverChatModels ?? remoteChatModels ?? defaultChatModels;
+  };
 
-const enableOpenrouter = (s: GlobalStore) => modelProvider(s).openrouter.enabled;
-const openrouterAPIKey = (s: GlobalStore) => modelProvider(s).openrouter.apiKey;
-
-const enableTogetherAI = (s: GlobalStore) => modelProvider(s).togetherai.enabled;
-const togetheraiAPIKey = (s: GlobalStore) => modelProvider(s).togetherai.apiKey;
-
-const enableZeroone = (s: GlobalStore) => modelProvider(s).zeroone.enabled;
-const zerooneAPIKey = (s: GlobalStore) => modelProvider(s).zeroone.apiKey;
-
-// const azureModelList = (s: GlobalStore): ModelProviderCard => {
-//   const azure = azureConfig(s);
-//   return {
-//     chatModels: parseModelString(azure.deployments),
-//     id: 'azure',
-//   };
-// };
-
-// 提取处理 chatModels 的专门方法
-const processChatModels = (
-  modelConfig: ReturnType<typeof parseModelString>,
-  defaultChartModels = OpenAIProvider.chatModels,
-): ChatModelCard[] => {
-  let chatModels = modelConfig.removeAll ? [] : defaultChartModels;
-
-  // 处理移除逻辑
-  if (!modelConfig.removeAll) {
-    chatModels = chatModels.filter((m) => !modelConfig.removed.includes(m.id));
-  }
-
-  return produce(chatModels, (draft) => {
-    // 处理添加或替换逻辑
-    for (const toAddModel of modelConfig.add) {
-      // first try to find the model in LOBE_DEFAULT_MODEL_LIST to confirm if it is a known model
-      const knownModel = LOBE_DEFAULT_MODEL_LIST.find((model) => model.id === toAddModel.id);
-
-      // if the model is known, update it based on the known model
-      if (knownModel) {
-        const modelInList = draft.find((model) => model.id === toAddModel.id);
-
-        // if the model is already in chatModels, update it
-        if (modelInList) {
-          if (modelInList.hidden) delete modelInList.hidden;
-          if (toAddModel.displayName) modelInList.displayName = toAddModel.displayName;
-        } else {
-          // if the model is not in chatModels, add it
-          draft.push({
-            ...knownModel,
-            displayName: toAddModel.displayName || knownModel.displayName || knownModel.id,
-            hidden: undefined,
-          });
-        }
-      } else {
-        // if the model is not in LOBE_DEFAULT_MODEL_LIST, add it as a new custom model
-        draft.push({
-          ...toAddModel,
-          displayName: toAddModel.displayName || toAddModel.id,
-          functionCall: true,
-          isCustom: true,
-          vision: true,
-        });
-      }
-    }
-  });
+  return [
+    {
+      ...OpenAIProviderCard,
+      chatModels: mergeModels('openai', OpenAIProviderCard.chatModels),
+    },
+    { ...AzureProviderCard, chatModels: [] },
+    { ...OllamaProviderCard, chatModels: mergeModels('ollama', OllamaProviderCard.chatModels) },
+    AnthropicProviderCard,
+    GoogleProviderCard,
+    {
+      ...OpenRouterProviderCard,
+      chatModels: mergeModels('openrouter', OpenRouterProviderCard.chatModels),
+    },
+    {
+      ...TogetherAIProviderCard,
+      chatModels: mergeModels('togetherai', TogetherAIProviderCard.chatModels),
+    },
+    BedrockProviderCard,
+    PerplexityProviderCard,
+    MistralProviderCard,
+    GroqProviderCard,
+    MoonshotProviderCard,
+    ZeroOneProviderCard,
+    ZhiPuProviderCard,
+  ];
 };
 
-const modelSelectList = (s: GlobalStore): ModelProviderCard[] => {
-  const openaiModelString = [
-    s.serverConfig.customModelName,
-    currentSettings(s).languageModel.openAI.customModelName,
-  ]
-    .filter(Boolean)
-    .join(',');
-
-  const openaiModelConfig = parseModelString(openaiModelString);
-
-  const openaiChatModels = processChatModels(openaiModelConfig);
-
-  const ollamaModelString = [
-    s.serverConfig.languageModel?.ollama?.customModelName,
-    currentSettings(s).languageModel.ollama.customModelName,
-  ]
-    .filter(Boolean)
-    .join(',');
-
-  const ollamaModelConfig = parseModelString(ollamaModelString);
+const providerCard = (provider: string) => (s: GlobalStore) =>
+  providerModelList(s).find((s) => s.id === provider);
 
-  const ollamaChatModels = processChatModels(ollamaModelConfig, OllamaProvider.chatModels);
+/**
+ * get the default enabled models for a provider
+ * it's a default enabled model list by Lobe Chat
+ * e.g. openai is ['gpt-3.5-turbo','gpt-4-turbo-preview','gpt-4-vision-preview']
+ */
+const defaultEnabledProviderModels = (provider: string) => (s: GlobalStore) => {
+  const modelProvider = providerCard(provider)(s);
 
-  const openrouterModelString = [
-    s.serverConfig.languageModel?.openrouter?.customModelName,
-    currentSettings(s).languageModel.openrouter.customModelName,
-  ]
-    .filter(Boolean)
-    .join(',');
+  if (modelProvider) return filterEnabledModels(modelProvider);
 
-  const openrouterModelConfig = parseModelString(openrouterModelString);
-
-  const openrouterChatModels = processChatModels(
-    openrouterModelConfig,
-    OpenRouterProvider.chatModels,
-  );
-
-  const togetheraiModelConfig = parseModelString(
-    currentSettings(s).languageModel.togetherai.customModelName,
-  );
-  const togetheraiChatModels = processChatModels(
-    togetheraiModelConfig,
-    TogetherAIProvider.chatModels,
-  );
-
-  return [
-    {
-      ...OpenAIProvider,
-      chatModels: openaiChatModels,
-    },
-    // { ...azureModelList(s), enabled: enableAzure(s) },
-    { ...OllamaProvider, chatModels: ollamaChatModels, enabled: enableOllama(s) },
-    { ...AnthropicProvider, enabled: enableAnthropic(s) },
-    { ...GoogleProvider, enabled: enableGoogle(s) },
-    { ...BedrockProvider, enabled: enableBedrock(s) },
-    { ...PerplexityProvider, enabled: enablePerplexity(s) },
-    { ...MistralProvider, enabled: enableMistral(s) },
-    { ...GroqProvider, enabled: enableGroq(s) },
-    { ...ZhiPuProvider, enabled: enableZhipu(s) },
-    { ...MoonshotProvider, enabled: enableMoonshot(s) },
-    { ...OpenRouterProvider, chatModels: openrouterChatModels, enabled: enableOpenrouter(s) },
-    { ...ZeroOneProvider, enabled: enableZeroone(s) },
-    { ...TogetherAIProvider, chatModels: togetheraiChatModels, enabled: enableTogetherAI(s) },
-  ];
+  return undefined;
 };
 
 const modelCardById = (id: string) => (s: GlobalStore) => {
-  const list = modelSelectList(s);
+  const list = providerModelList(s);
 
   return list.flatMap((i) => i.chatModels).find((m) => m.id === id);
 };
@@ -222,7 +138,9 @@ const modelMaxToken = (id: string) => (s: GlobalStore) => modelCardById(id)(s)?.
 
 /* eslint-disable sort-keys-fix/sort-keys-fix,  */
 export const modelProviderSelectors = {
-  modelSelectList,
+  providerModelList,
+  providerCard,
+  defaultEnabledProviderModels,
 
   modelCardById,
   modelMaxToken,
@@ -232,63 +150,4 @@ export const modelProviderSelectors = {
   modelEnabledVision,
   modelEnabledFiles,
   modelEnabledUpload,
-
-  modelProviderConfig: modelProvider,
-  providerEnabled,
-
-  // OpenAI
-  openAIConfig,
-  openAIAPIKey,
-  openAIProxyUrl,
-  // Azure OpenAI
-  enableAzure,
-  azureConfig,
-  // Zhipu
-  enableZhipu,
-  zhipuAPIKey,
-  zhipuProxyUrl,
-  // Google
-  enableGoogle,
-  googleAPIKey,
-  googleProxyUrl,
-  // Bedrock
-  enableBedrock,
-  bedrockConfig,
-
-  // Moonshot
-  enableMoonshot,
-  moonshotAPIKey,
-
-  // Ollama
-  enableOllama,
-  ollamaProxyUrl,
-
-  // Perplexity
-  enablePerplexity,
-  perplexityAPIKey,
-
-  // Anthropic
-  enableAnthropic,
-  anthropicAPIKey,
-  anthropicProxyUrl,
-
-  // Mistral
-  enableMistral,
-  mistralAPIKey,
-
-  // Groq
-  enableGroq,
-  groqAPIKey,
-
-  // OpenRouter
-  enableOpenrouter,
-  openrouterAPIKey,
-
-  // ZeroOne 零一万物
-  enableZeroone,
-  zerooneAPIKey,
-
-  // TogetherAI
-  enableTogetherAI,
-  togetheraiAPIKey,
 };

package/src/store/global/store.ts

@@ -9,7 +9,7 @@ import { createHyperStorage } from '../middleware/createHyperStorage';
 import { type GlobalState, initialState } from './initialState';
 import { type CommonAction, createCommonSlice } from './slices/common/action';
 import { type PreferenceAction, createPreferenceSlice } from './slices/preference/action';
-import { type SettingsAction, createSettingsSlice } from './slices/settings/action';
+import { type SettingsAction, createSettingsSlice } from './slices/settings/actions';
 
 //  ===============  聚合 createStoreFn ============ //
 

package/src/types/llm.ts

@@ -1,6 +1,18 @@
 export interface ChatModelCard {
+  /**
+   * only used in azure
+   */
+  deploymentName?: string;
   description?: string;
+  /**
+   * the name show for end user
+   */
   displayName?: string;
+
+  /**
+   * whether model is enabled by default
+   */
+  enabled?: boolean;
   /**
    * whether model supports file upload
    */
@@ -9,7 +21,6 @@ export interface ChatModelCard {
    * whether model supports function call
    */
   functionCall?: boolean;
-  hidden?: boolean;
   id: string;
   /**
    * whether model is custom

package/src/types/serverConfig.ts

@@ -0,0 +1,22 @@
+import { DeepPartial } from 'utility-types';
+
+import { ChatModelCard } from '@/types/llm';
+import { GlobalDefaultAgent, GlobalLLMProviderKey } from '@/types/settings';
+
+export interface ServerModelProviderConfig {
+  enabled?: boolean;
+
+  /**
+   * the model cards defined in server
+   */
+  serverModelCards?: ChatModelCard[];
+}
+
+export interface GlobalServerConfig {
+  defaultAgent?: DeepPartial<GlobalDefaultAgent>;
+  enabledOAuthSSO?: boolean;
+  languageModel?: Partial<Record<GlobalLLMProviderKey, ServerModelProviderConfig>>;
+  telemetry: {
+    langfuse?: boolean;
+  };
+}

package/src/types/settings/index.ts

@@ -1,5 +1,3 @@
-import { DeepPartial } from 'utility-types';
-
 import type { LobeAgentSession } from '@/types/session';
 
 import { GlobalBaseSettings } from './base';
@@ -20,16 +18,6 @@ export interface GlobalTool {
   };
 }
 
-export interface GlobalServerConfig {
-  customModelName?: string;
-  defaultAgent?: DeepPartial<GlobalDefaultAgent>;
-  enabledOAuthSSO?: boolean;
-  languageModel?: DeepPartial<GlobalLLMConfig>;
-  telemetry: {
-    langfuse?: boolean;
-  };
-}
-
 /**
  * 配置设置
  */

package/src/types/settings/modelProvider.ts

@@ -1,114 +1,58 @@
+import { ChatModelCard } from '@/types/llm';
+
 export type CustomModels = { displayName: string; id: string }[];
 
-export interface OpenAIConfig {
-  OPENAI_API_KEY: string;
-  azureApiVersion?: string;
+export interface GeneralModelProviderConfig {
+  apiKey?: string;
+  /**
+   * whether to auto fetch model lists
+   */
+  autoFetchModelLists?: boolean;
   /**
-   * custom mode name for fine-tuning or openai like model
+   * user defined model cards
    */
-  customModelName?: string;
+  customModelCards?: ChatModelCard[];
   enabled: boolean;
+  /**
+   * enabled models id
+   */
+  enabledModels?: string[] | null;
   endpoint?: string;
   /**
-   * @deprecated
+   * the latest fetch model list time
+   */
+  latestFetchTime?: number;
+  /**
+   * fetched models from provider side
    */
-  models?: string[];
-  useAzure?: boolean;
+  remoteModelCards?: ChatModelCard[];
 }
 
-export interface AzureOpenAIConfig {
-  apiKey: string;
+export interface AzureOpenAIConfig extends GeneralModelProviderConfig {
   apiVersion?: string;
-  deployments: string;
-  enabled: boolean;
-  endpoint?: string;
-}
-
-export interface ZhiPuConfig {
-  apiKey?: string;
-  enabled: boolean;
-  endpoint?: string;
-}
-
-export interface MoonshotConfig {
-  apiKey?: string;
-  enabled: boolean;
-}
-
-export interface GoogleConfig {
-  apiKey?: string;
-  enabled: boolean;
-  endpoint?: string;
 }
 
-export interface AWSBedrockConfig {
+export interface AWSBedrockConfig extends Omit<GeneralModelProviderConfig, 'apiKey' | 'endpoint'> {
   accessKeyId?: string;
-  enabled: boolean;
   region?: string;
   secretAccessKey?: string;
 }
 
-export interface OllamaConfig {
-  customModelName?: string;
-  enabled?: boolean;
-  endpoint?: string;
-}
-
-export interface PerplexityConfig {
-  apiKey?: string;
-  enabled: boolean;
-  endpoint?: string;
-}
-
-export interface AnthropicConfig {
-  apiKey?: string;
-  enabled: boolean;
-  endpoint?: string;
-}
-
-export interface MistralConfig {
-  apiKey?: string;
-  enabled: boolean;
-}
-
-export interface GroqConfig {
-  apiKey?: string;
-  enabled: boolean;
-}
-
-export interface OpenRouterConfig {
-  apiKey?: string;
-  customModelName?: string;
-  enabled?: boolean;
-}
-
-export interface ZeroOneConfig {
-  apiKey?: string;
-  customModelName?: string;
-  enabled?: boolean;
-}
-
-export interface TogetherAIConfig {
-  apiKey?: string;
-  customModelName?: string;
-  enabled?: boolean;
-}
-
 export interface GlobalLLMConfig {
-  anthropic: AnthropicConfig;
+  anthropic: GeneralModelProviderConfig;
   azure: AzureOpenAIConfig;
   bedrock: AWSBedrockConfig;
-  google: GoogleConfig;
-  groq: GroqConfig;
-  mistral: MistralConfig;
-  moonshot: MoonshotConfig;
-  ollama: OllamaConfig;
-  openAI: OpenAIConfig;
-  openrouter: OpenRouterConfig;
-  perplexity: PerplexityConfig;
-  togetherai: TogetherAIConfig;
-  zeroone: ZeroOneConfig;
-  zhipu: ZhiPuConfig;
+  google: GeneralModelProviderConfig;
+  groq: GeneralModelProviderConfig;
+  mistral: GeneralModelProviderConfig;
+  moonshot: GeneralModelProviderConfig;
+  ollama: GeneralModelProviderConfig;
+  openai: GeneralModelProviderConfig;
+  openrouter: GeneralModelProviderConfig;
+  perplexity: GeneralModelProviderConfig;
+  togetherai: GeneralModelProviderConfig;
+  zeroone: GeneralModelProviderConfig;
+  zhipu: GeneralModelProviderConfig;
 }
 
 export type GlobalLLMProviderKey = keyof GlobalLLMConfig;

package/src/utils/client/switchLang.test.ts

@@ -0,0 +1,34 @@
+import { changeLanguage } from 'i18next';
+import { describe, expect, it, vi } from 'vitest';
+
+import { LocaleMode } from '@/types/locale';
+
+import { switchLang } from './switchLang';
+
+vi.mock('i18next', () => ({
+  changeLanguage: vi.fn(),
+}));
+
+describe('switchLang', () => {
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('should change language to the specified locale', () => {
+    const locale: LocaleMode = 'en-US';
+    switchLang(locale);
+
+    expect(changeLanguage).toHaveBeenCalledWith(locale);
+    expect(document.documentElement.lang).toBe(locale);
+  });
+
+  it('should change language based on navigator.language when locale is "auto"', () => {
+    const navigatorLanguage = 'fr';
+    vi.spyOn(navigator, 'language', 'get').mockReturnValue(navigatorLanguage);
+
+    switchLang('auto');
+
+    expect(changeLanguage).toHaveBeenCalledWith(navigatorLanguage);
+    expect(document.documentElement.lang).toBe(navigatorLanguage);
+  });
+});