@lobehub/chat 0.150.1 → 0.150.3

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 # Changelog
 
+### [Version 0.150.3](https://github.com/lobehub/lobe-chat/compare/v0.150.2...v0.150.3)
+
+<sup>Released on **2024-04-27**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix docker build.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix docker build, closes [#2236](https://github.com/lobehub/lobe-chat/issues/2236) ([749a843](https://github.com/lobehub/lobe-chat/commit/749a843))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 0.150.2](https://github.com/lobehub/lobe-chat/compare/v0.150.1...v0.150.2)
+
+<sup>Released on **2024-04-27**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix display error when using `DEFAULT_AGENT_CONFIG` env.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix display error when using `DEFAULT_AGENT_CONFIG` env, closes [#2231](https://github.com/lobehub/lobe-chat/issues/2231) ([42bc734](https://github.com/lobehub/lobe-chat/commit/42bc734))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 0.150.1](https://github.com/lobehub/lobe-chat/compare/v0.150.0...v0.150.1)
 
 <sup>Released on **2024-04-27**</sup>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "0.150.1",
+  "version": "0.150.3",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",
@@ -82,6 +82,7 @@
   "dependencies": {
     "@ant-design/icons": "^5.3.6",
     "@anthropic-ai/sdk": "^0.18.0",
+    "@auth/core": "0.28.0",
     "@aws-sdk/client-bedrock-runtime": "^3.556.0",
     "@azure/openai": "^1.0.0-beta.12",
     "@cfworker/json-schema": "^1.12.8",

package/src/layout/GlobalProvider/StoreInitialization.tsx

@@ -6,6 +6,7 @@ import { createStoreUpdater } from 'zustand-utils';
 
 import { useIsMobile } from '@/hooks/useIsMobile';
 import { useEnabledDataSync } from '@/hooks/useSyncData';
+import { useAgentStore } from '@/store/agent';
 import { useGlobalStore } from '@/store/global';
 
 const StoreInitialization = memo(() => {
@@ -14,8 +15,10 @@ const StoreInitialization = memo(() => {
     s.useFetchUserConfig,
     s.useInitPreference,
   ]);
+  const useFetchDefaultAgentConfig = useAgentStore((s) => s.useFetchDefaultAgentConfig);
   // init the system preference
   useInitPreference();
+  useFetchDefaultAgentConfig();
 
   const { isLoading } = useFetchServerConfig();
   useFetchUserConfig(!isLoading);

package/src/server/context.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { NextRequest } from 'next/server';
 
-interface AuthContext {
+export interface AuthContext {
   userId?: string | null;
 }
 
@@ -9,11 +9,9 @@ interface AuthContext {
  * Inner function for `createContext` where we create the context.
  * This is useful for testing when we don't want to mock Next.js' request/response
  */
-export function createContextInner(): AuthContext {
-  return {
-    userId: null,
-  };
-}
+export const createContextInner = async (): Promise<AuthContext> => ({
+  userId: null,
+});
 
 export type Context = Awaited<ReturnType<typeof createContextInner>>;
 

package/src/server/mock.ts

@@ -0,0 +1,8 @@
+/**
+ * This file contains the root router of your tRPC-backend
+ */
+import { createCallerFactory } from '@/libs/trpc';
+
+import { appRouter } from './routers';
+
+export const createCaller = createCallerFactory(appRouter);

package/src/{app/api/config/__snapshots__/route.test.ts.snap → server/routers/config/__snapshots__/index.test.ts.snap}

@@ -1,6 +1,6 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
-exports[`GET /api/config > Model Provider env > CUSTOM_MODELS > custom deletion, addition, and renaming of models 1`] = `
+exports[`configRouter > getGlobalConfig > Model Provider env > CUSTOM_MODELS > custom deletion, addition, and renaming of models 1`] = `
 [
   {
     "displayName": "llama",
@@ -22,7 +22,7 @@ exports[`GET /api/config > Model Provider env > CUSTOM_MODELS > custom deletion,
 ]
 `;
 
-exports[`GET /api/config > Model Provider env > OPENAI_MODEL_LIST > custom deletion, addition, and renaming of models 1`] = `
+exports[`configRouter > getGlobalConfig > Model Provider env > OPENAI_MODEL_LIST > custom deletion, addition, and renaming of models 1`] = `
 {
   "enabledModels": [
     "llama",
@@ -51,7 +51,7 @@ exports[`GET /api/config > Model Provider env > OPENAI_MODEL_LIST > custom delet
 }
 `;
 
-exports[`GET /api/config > Model Provider env > OPENAI_MODEL_LIST > should work correct with gpt-4 1`] = `
+exports[`configRouter > getGlobalConfig > Model Provider env > OPENAI_MODEL_LIST > should work correct with gpt-4 1`] = `
 [
   {
     "displayName": "GPT-3.5 Turbo (1106)",
@@ -106,7 +106,7 @@ exports[`GET /api/config > Model Provider env > OPENAI_MODEL_LIST > should work
 ]
 `;
 
-exports[`GET /api/config > Model Provider env > OPENROUTER_MODEL_LIST > custom deletion, addition, and renaming of models 1`] = `
+exports[`configRouter > getGlobalConfig > Model Provider env > OPENROUTER_MODEL_LIST > custom deletion, addition, and renaming of models 1`] = `
 {
   "enabled": false,
   "enabledModels": [

package/src/server/routers/config/index.test.ts

@@ -0,0 +1,194 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+/**
+ * This file contains the root router of your tRPC-backend
+ */
+import { createCallerFactory } from '@/libs/trpc';
+import { AuthContext, createContextInner } from '@/server/context';
+import { GlobalServerConfig } from '@/types/serverConfig';
+
+import { configRouter } from './index';
+
+const createCaller = createCallerFactory(configRouter);
+let ctx: AuthContext;
+let router: ReturnType<typeof createCaller>;
+
+beforeEach(async () => {
+  vi.resetAllMocks();
+  ctx = await createContextInner();
+  router = createCaller(ctx);
+});
+
+describe('configRouter', () => {
+  describe('getGlobalConfig', () => {
+    describe('Model Provider env', () => {
+      describe('OPENAI_MODEL_LIST', () => {
+        it('custom deletion, addition, and renaming of models', async () => {
+          process.env.OPENAI_MODEL_LIST =
+            '-all,+llama,+claude-2，-gpt-3.5-turbo,gpt-4-0125-preview=gpt-4-turbo,gpt-4-0125-preview=gpt-4-32k';
+
+          const response = await router.getGlobalConfig();
+
+          // Assert
+          const result = response.languageModel?.openai;
+
+          expect(result).toMatchSnapshot();
+          process.env.OPENAI_MODEL_LIST = '';
+        });
+
+        it('should work correct with gpt-4', async () => {
+          process.env.OPENAI_MODEL_LIST =
+            '-all,+gpt-3.5-turbo-1106,+gpt-3.5-turbo,+gpt-3.5-turbo-16k,+gpt-4,+gpt-4-32k,+gpt-4-1106-preview,+gpt-4-vision-preview';
+
+          const response = await router.getGlobalConfig();
+
+          const result = response.languageModel?.openai?.serverModelCards;
+
+          expect(result).toMatchSnapshot();
+
+          process.env.OPENAI_MODEL_LIST = '';
+        });
+
+        it('duplicate naming model', async () => {
+          process.env.OPENAI_MODEL_LIST =
+            'gpt-4-0125-preview=gpt-4-turbo，gpt-4-0125-preview=gpt-4-32k';
+
+          const response = await router.getGlobalConfig();
+
+          const result = response.languageModel?.openai?.serverModelCards;
+
+          expect(result?.find((s) => s.id === 'gpt-4-0125-preview')?.displayName).toEqual(
+            'gpt-4-32k',
+          );
+
+          process.env.OPENAI_MODEL_LIST = '';
+        });
+
+        it('should delete model', async () => {
+          process.env.OPENAI_MODEL_LIST = '-gpt-4';
+
+          const response = await router.getGlobalConfig();
+
+          const result = response.languageModel?.openai?.serverModelCards;
+
+          expect(result?.find((r) => r.id === 'gpt-4')).toBeUndefined();
+
+          process.env.OPENAI_MODEL_LIST = '';
+        });
+
+        it('show the hidden model', async () => {
+          process.env.OPENAI_MODEL_LIST = '+gpt-4-1106-preview';
+
+          const response = await router.getGlobalConfig();
+
+          const result = response.languageModel?.openai?.serverModelCards;
+
+          expect(result?.find((o) => o.id === 'gpt-4-1106-preview')).toEqual({
+            displayName: 'GPT-4 Turbo Preview (1106)',
+            functionCall: true,
+            enabled: true,
+            id: 'gpt-4-1106-preview',
+            tokens: 128000,
+          });
+
+          process.env.OPENAI_MODEL_LIST = '';
+        });
+
+        it('only add the model', async () => {
+          process.env.OPENAI_MODEL_LIST = 'model1,model2,model3，model4';
+
+          const response = await router.getGlobalConfig();
+
+          const result = response.languageModel?.openai?.serverModelCards;
+
+          expect(result).toContainEqual({
+            displayName: 'model1',
+            id: 'model1',
+            enabled: true,
+          });
+          expect(result).toContainEqual({
+            displayName: 'model2',
+            enabled: true,
+            id: 'model2',
+          });
+          expect(result).toContainEqual({
+            displayName: 'model3',
+            enabled: true,
+            id: 'model3',
+          });
+          expect(result).toContainEqual({
+            displayName: 'model4',
+            enabled: true,
+            id: 'model4',
+          });
+
+          process.env.OPENAI_MODEL_LIST = '';
+        });
+      });
+
+      describe('CUSTOM_MODELS', () => {
+        it('custom deletion, addition, and renaming of models', async () => {
+          process.env.CUSTOM_MODELS =
+            '-all,+llama,+claude-2，-gpt-3.5-turbo,gpt-4-0125-preview=gpt-4-turbo,gpt-4-0125-preview=gpt-4-32k';
+
+          const response = await router.getGlobalConfig();
+
+          // Assert
+          const result = response.languageModel?.openai?.serverModelCards;
+
+          expect(result).toMatchSnapshot();
+        });
+      });
+
+      describe('OPENROUTER_MODEL_LIST', () => {
+        it('custom deletion, addition, and renaming of models', async () => {
+          process.env.OPENROUTER_MODEL_LIST =
+            '-all,+google/gemma-7b-it,+mistralai/mistral-7b-instruct=Mistral-7B-Instruct';
+
+          const response = await router.getGlobalConfig();
+
+          // Assert
+          const result = response.languageModel?.openrouter;
+
+          expect(result).toMatchSnapshot();
+
+          process.env.OPENROUTER_MODEL_LIST = '';
+        });
+      });
+    });
+  });
+
+  describe('getDefaultAgentConfig', () => {
+    it('should return the default agent config', async () => {
+      process.env.DEFAULT_AGENT_CONFIG =
+        'plugins=search-engine,lobe-image-designer;enableAutoCreateTopic=true;model=gemini-pro;provider=google;';
+
+      const response = await router.getDefaultAgentConfig();
+
+      expect(response).toEqual({
+        enableAutoCreateTopic: true,
+        model: 'gemini-pro',
+        plugins: ['search-engine', 'lobe-image-designer'],
+        provider: 'google',
+      });
+
+      process.env.DEFAULT_AGENT_CONFIG = '';
+    });
+
+    it('should return another config', async () => {
+      process.env.DEFAULT_AGENT_CONFIG =
+        'model=meta-11ama/11ama-3-70b-instruct:nitro;provider=openrouter;enableAutoCreateTopic=true;params.max_tokens=700';
+
+      const response = await router.getDefaultAgentConfig();
+
+      expect(response).toEqual({
+        enableAutoCreateTopic: true,
+        model: 'meta-11ama/11ama-3-70b-instruct:nitro',
+        params: { max_tokens: 700 },
+        provider: 'openrouter',
+      });
+
+      process.env.DEFAULT_AGENT_CONFIG = '';
+    });
+  });
+});

package/src/server/routers/config/index.ts

@@ -0,0 +1,121 @@
+import {
+  OllamaProviderCard,
+  OpenAIProviderCard,
+  OpenRouterProviderCard,
+  TogetherAIProviderCard,
+} from '@/config/modelProviders';
+import { getServerConfig } from '@/config/server';
+import { publicProcedure, router } from '@/libs/trpc';
+import { parseAgentConfig } from '@/server/routers/config/parseDefaultAgent';
+import { GlobalServerConfig } from '@/types/serverConfig';
+import { extractEnabledModels, transformToChatModelCards } from '@/utils/parseModels';
+
+export const configRouter = router({
+  getDefaultAgentConfig: publicProcedure.query(async () => {
+    const { DEFAULT_AGENT_CONFIG } = getServerConfig();
+
+    return parseAgentConfig(DEFAULT_AGENT_CONFIG) || {};
+  }),
+
+  getGlobalConfig: publicProcedure.query(async () => {
+    const {
+      ENABLE_LANGFUSE,
+      ENABLE_OAUTH_SSO,
+
+      DEFAULT_AGENT_CONFIG,
+      OPENAI_MODEL_LIST,
+
+      ENABLED_MOONSHOT,
+      ENABLED_ZHIPU,
+      ENABLED_AWS_BEDROCK,
+      ENABLED_GOOGLE,
+      ENABLED_GROQ,
+      ENABLED_PERPLEXITY,
+      ENABLED_ANTHROPIC,
+      ENABLED_MISTRAL,
+
+      ENABLED_AZURE_OPENAI,
+      AZURE_MODEL_LIST,
+
+      ENABLE_OLLAMA,
+      OLLAMA_MODEL_LIST,
+      OLLAMA_PROXY_URL,
+
+      ENABLED_OPENROUTER,
+      OPENROUTER_MODEL_LIST,
+
+      ENABLED_ZEROONE,
+      ENABLED_TOGETHERAI,
+      TOGETHERAI_MODEL_LIST,
+    } = getServerConfig();
+
+    const config: GlobalServerConfig = {
+      defaultAgent: {
+        config: parseAgentConfig(DEFAULT_AGENT_CONFIG),
+      },
+
+      enabledOAuthSSO: ENABLE_OAUTH_SSO,
+      languageModel: {
+        anthropic: {
+          enabled: ENABLED_ANTHROPIC,
+        },
+        azure: {
+          enabled: ENABLED_AZURE_OPENAI,
+          enabledModels: extractEnabledModels(AZURE_MODEL_LIST, true),
+          serverModelCards: transformToChatModelCards({
+            defaultChatModels: [],
+            modelString: AZURE_MODEL_LIST,
+            withDeploymentName: true,
+          }),
+        },
+        bedrock: { enabled: ENABLED_AWS_BEDROCK },
+        google: { enabled: ENABLED_GOOGLE },
+        groq: { enabled: ENABLED_GROQ },
+        mistral: { enabled: ENABLED_MISTRAL },
+        moonshot: { enabled: ENABLED_MOONSHOT },
+        ollama: {
+          enabled: ENABLE_OLLAMA,
+          fetchOnClient: !OLLAMA_PROXY_URL,
+          serverModelCards: transformToChatModelCards({
+            defaultChatModels: OllamaProviderCard.chatModels,
+            modelString: OLLAMA_MODEL_LIST,
+          }),
+        },
+        openai: {
+          enabledModels: extractEnabledModels(OPENAI_MODEL_LIST),
+          serverModelCards: transformToChatModelCards({
+            defaultChatModels: OpenAIProviderCard.chatModels,
+            modelString: OPENAI_MODEL_LIST,
+          }),
+        },
+
+        openrouter: {
+          enabled: ENABLED_OPENROUTER,
+          enabledModels: extractEnabledModels(OPENROUTER_MODEL_LIST),
+          serverModelCards: transformToChatModelCards({
+            defaultChatModels: OpenRouterProviderCard.chatModels,
+            modelString: OPENROUTER_MODEL_LIST,
+          }),
+        },
+        perplexity: { enabled: ENABLED_PERPLEXITY },
+
+        togetherai: {
+          enabled: ENABLED_TOGETHERAI,
+          enabledModels: extractEnabledModels(TOGETHERAI_MODEL_LIST),
+          serverModelCards: transformToChatModelCards({
+            defaultChatModels: TogetherAIProviderCard.chatModels,
+            modelString: TOGETHERAI_MODEL_LIST,
+          }),
+        },
+
+        zeroone: { enabled: ENABLED_ZEROONE },
+        zhipu: { enabled: ENABLED_ZHIPU },
+      },
+      telemetry: {
+        langfuse: ENABLE_LANGFUSE,
+      },
+    };
+
+    return config;
+  }),
+});

package/src/server/routers/index.ts

@@ -3,7 +3,10 @@
  */
 import { publicProcedure, router } from '@/libs/trpc';
 
+import { configRouter } from './config';
+
 export const appRouter = router({
+  config: configRouter,
   healthcheck: publicProcedure.query(() => "i'm live!"),
 });
 

package/src/services/__tests__/global.test.ts

@@ -1,5 +1,9 @@
 import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { trpcClient } from '@/libs/trpc/client';
+import { LobeAgentConfig } from '@/types/agent';
+import { GlobalServerConfig } from '@/types/serverConfig';
+
 import { globalService } from '../global';
 
 global.fetch = vi.fn();
@@ -8,6 +12,17 @@ beforeEach(() => {
   vi.clearAllMocks();
 });
 
+vi.mock('@/libs/trpc/client', () => {
+  return {
+    trpcClient: {
+      config: {
+        getGlobalConfig: { query: vi.fn() },
+        getDefaultAgentConfig: { query: vi.fn() },
+      },
+    },
+  };
+});
+
 describe('GlobalService', () => {
   describe('getLatestVersion', () => {
     it('should return the latest version when fetch is successful', async () => {
@@ -60,15 +75,27 @@ describe('GlobalService', () => {
   describe('ServerConfig', () => {
     it('should return the serverConfig when fetch is successful', async () => {
       // Arrange
-      (fetch as Mock).mockResolvedValue({
-        json: () => Promise.resolve({ customModelName: 'abc' }),
-      });
+      const mockConfig = { enabledOAuthSSO: true } as GlobalServerConfig;
+      vi.spyOn(trpcClient.config.getGlobalConfig, 'query').mockResolvedValue(mockConfig);
 
       // Act
       const config = await globalService.getGlobalConfig();
 
       // Assert
-      expect(config).toEqual({ customModelName: 'abc' });
+      expect(config).toEqual({ enabledOAuthSSO: true });
+    });
+
+    it('should return the defaultAgentConfig when fetch is successful', async () => {
+      // Arrange
+      vi.spyOn(trpcClient.config.getDefaultAgentConfig, 'query').mockResolvedValue({
+        model: 'gemini-pro',
+      });
+
+      // Act
+      const config = await globalService.getDefaultAgentConfig();
+
+      // Assert
+      expect(config).toEqual({ model: 'gemini-pro' });
     });
   });
 });

package/src/services/_url.ts

@@ -15,7 +15,6 @@ const mapWithBasePath = <T extends object>(apis: T): T => {
 };
 
 export const API_ENDPOINTS = mapWithBasePath({
-  config: '/api/config',
   proxy: '/api/proxy',
   oauth: '/api/auth',
 

package/src/services/global.ts

@@ -1,9 +1,11 @@
+import { DeepPartial } from 'utility-types';
+
 import { dataSync } from '@/database/client/core';
+import { trpcClient } from '@/libs/trpc/client';
+import { LobeAgentConfig } from '@/types/agent';
 import { GlobalServerConfig } from '@/types/serverConfig';
 import { StartDataSyncParams } from '@/types/sync';
 
-import { API_ENDPOINTS } from './_url';
-
 const VERSION_URL = 'https://registry.npmmirror.com/@lobehub/chat';
 
 class GlobalService {
@@ -18,9 +20,11 @@ class GlobalService {
   };
 
   getGlobalConfig = async (): Promise<GlobalServerConfig> => {
-    const res = await fetch(API_ENDPOINTS.config);
+    return trpcClient.config.getGlobalConfig.query();
+  };
 
-    return res.json();
+  getDefaultAgentConfig = async (): Promise<DeepPartial<LobeAgentConfig>> => {
+    return trpcClient.config.getDefaultAgentConfig.query();
   };
 
   enabledSync = async (params: StartDataSyncParams) => {

package/src/store/agent/initialState.ts

@@ -1,7 +1,7 @@
-import { AgentState, initialSessionState } from './slices/chat/initialState';
+import { AgentState, initialAgentChatState } from './slices/chat/initialState';
 
 export type SessionStoreState = AgentState;
 
 export const initialState: SessionStoreState = {
-  ...initialSessionState,
+  ...initialAgentChatState,
 };

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

@@ -1,11 +1,22 @@
-import { act, renderHook } from '@testing-library/react';
-import * as immer from 'immer';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { mutate } from 'swr';
 import { describe, expect, it, vi } from 'vitest';
 
+import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
+import { globalService } from '@/services/global';
 import { sessionService } from '@/services/session';
 import { useAgentStore } from '@/store/agent';
 import { agentSelectors } from '@/store/agent/selectors';
-import { useGlobalStore } from '@/store/global';
+import { useSessionStore } from '@/store/session';
+
+vi.mock('zustand/traditional');
+vi.mock('swr', async (importOriginal) => {
+  const origin = await importOriginal();
+  return {
+    ...(origin as any),
+    mutate: vi.fn(),
+  };
+});
 
 describe('AgentSlice', () => {
   describe('removePlugin', () => {
@@ -135,4 +146,146 @@ describe('AgentSlice', () => {
       updateSessionConfigMock.mockRestore();
     });
   });
+
+  describe('useFetchAgentConfig', () => {
+    it('should update agentConfig and isAgentConfigInit when data changes and isAgentConfigInit is false', async () => {
+      const { result } = renderHook(() => useAgentStore());
+
+      act(() => {
+        result.current.isAgentConfigInit = false;
+        result.current.agentConfig = { model: 'gpt-3.5-turbo' };
+      });
+
+      vi.spyOn(sessionService, 'getSessionConfig').mockResolvedValueOnce({ model: 'gpt-4' } as any);
+
+      renderHook(() => result.current.useFetchAgentConfig('test-session-id'));
+
+      await waitFor(() => {
+        expect(result.current.agentConfig).toEqual({ model: 'gpt-4' });
+        expect(result.current.isAgentConfigInit).toBe(true);
+      });
+    });
+
+    it('should not update state when data is the same and isAgentConfigInit is true', async () => {
+      const { result } = renderHook(() => useAgentStore());
+
+      act(() => {
+        useAgentStore.setState({ isAgentConfigInit: true });
+      });
+
+      vi.spyOn(useSessionStore, 'setState');
+      vi.spyOn(sessionService, 'getSessionConfig').mockResolvedValueOnce({
+        model: 'gpt-3.5-turbo',
+      } as any);
+
+      renderHook(() => result.current.useFetchAgentConfig('test-session-id'));
+
+      await waitFor(() => {
+        expect(result.current.agentConfig).toEqual({ model: 'gpt-3.5-turbo' });
+        expect(result.current.isAgentConfigInit).toBe(true);
+
+        expect(useSessionStore.setState).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('useFetchDefaultAgentConfig', () => {
+    it('should merge DEFAULT_AGENT_CONFIG and update defaultAgentConfig and isDefaultAgentConfigInit on success', async () => {
+      const { result } = renderHook(() => useAgentStore());
+      vi.spyOn(globalService, 'getDefaultAgentConfig').mockResolvedValue({ model: 'gemini-pro' });
+
+      renderHook(() => result.current.useFetchDefaultAgentConfig());
+
+      await waitFor(async () => {
+        expect(result.current.defaultAgentConfig).toEqual({
+          ...DEFAULT_AGENT_CONFIG,
+          model: 'gemini-pro',
+        });
+        expect(result.current.isDefaultAgentConfigInit).toBe(true);
+      });
+    });
+
+    it('should not modify state on failure', async () => {
+      const { result } = renderHook(() => useAgentStore());
+
+      vi.spyOn(globalService, 'getDefaultAgentConfig').mockRejectedValueOnce(new Error());
+
+      renderHook(() => result.current.useFetchDefaultAgentConfig());
+
+      await waitFor(async () => {
+        expect(result.current.defaultAgentConfig).toEqual(DEFAULT_AGENT_CONFIG);
+        expect(result.current.isDefaultAgentConfigInit).toBe(false);
+      });
+    });
+  });
+
+  describe('internal_updateAgentConfig', () => {
+    it('should call sessionService.updateSessionConfig', async () => {
+      const { result } = renderHook(() => useAgentStore());
+
+      const updateSessionConfigMock = vi.spyOn(sessionService, 'updateSessionConfig');
+
+      await act(async () => {
+        await result.current.internal_updateAgentConfig('test-session-id', { foo: 'bar' } as any);
+      });
+
+      expect(updateSessionConfigMock).toHaveBeenCalledWith('test-session-id', { foo: 'bar' });
+    });
+
+    it('should trigger internal_refreshAgentConfig', async () => {
+      const { result } = renderHook(() => useAgentStore());
+
+      const refreshMock = vi.spyOn(result.current, 'internal_refreshAgentConfig');
+
+      await act(async () => {
+        await result.current.internal_updateAgentConfig('test-session-id', {});
+      });
+
+      expect(refreshMock).toHaveBeenCalledWith('test-session-id');
+    });
+
+    it('should trigger useSessionStore.refreshSessions when model changes', async () => {
+      const { result } = renderHook(() => useAgentStore());
+
+      vi.spyOn(agentSelectors, 'currentAgentModel').mockReturnValueOnce('gpt-3.5-turbo');
+
+      const refreshSessionsMock = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
+
+      await act(async () => {
+        await result.current.internal_updateAgentConfig('test-session-id', { model: 'gpt-4' });
+      });
+
+      expect(refreshSessionsMock).toHaveBeenCalled();
+    });
+  });
+
+  describe('internal_refreshAgentConfig', () => {
+    it('should call mutate with correct key', async () => {
+      const { result } = renderHook(() => useAgentStore());
+
+      await act(async () => {
+        await result.current.internal_refreshAgentConfig('test-session-id');
+      });
+
+      expect(mutate).toHaveBeenCalledWith(['FETCH_AGENT_CONFIG', 'test-session-id']);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should not update config if activeId is null', async () => {
+      const { result } = renderHook(() => useAgentStore());
+
+      act(() => {
+        useAgentStore.setState({ activeId: null } as any);
+      });
+
+      const updateMock = vi.spyOn(result.current, 'internal_updateAgentConfig');
+
+      await act(async () => {
+        await result.current.updateAgentConfig({});
+      });
+
+      expect(updateMock).not.toHaveBeenCalled();
+    });
+  });
 });

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

@@ -1,10 +1,12 @@
 import isEqual from 'fast-deep-equal';
 import { produce } from 'immer';
-import { SWRResponse, mutate } from 'swr';
+import useSWR, { SWRResponse, mutate } from 'swr';
 import { DeepPartial } from 'utility-types';
 import { StateCreator } from 'zustand/vanilla';
 
+import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { useClientDataSWR } from '@/libs/swr';
+import { globalService } from '@/services/global';
 import { sessionService } from '@/services/session';
 import { useSessionStore } from '@/store/session';
 import { LobeAgentConfig } from '@/types/agent';
@@ -22,6 +24,7 @@ export interface AgentChatAction {
   updateAgentConfig: (config: Partial<LobeAgentConfig>) => Promise<void>;
 
   useFetchAgentConfig: (id: string) => SWRResponse<LobeAgentConfig>;
+  useFetchDefaultAgentConfig: () => SWRResponse<DeepPartial<LobeAgentConfig>>;
 
   /* eslint-disable typescript-sort-keys/interface */
 
@@ -73,7 +76,6 @@ export const createChatSlice: StateCreator<
 
     await get().internal_updateAgentConfig(activeId, config);
   },
-
   useFetchAgentConfig: (sessionId) =>
     useClientDataSWR<LobeAgentConfig>(
       [FETCH_AGENT_CONFIG_KEY, sessionId],
@@ -86,6 +88,26 @@ export const createChatSlice: StateCreator<
         },
       },
     ),
+  useFetchDefaultAgentConfig: () =>
+    useSWR<DeepPartial<LobeAgentConfig>>(
+      'fetchDefaultAgentConfig',
+      globalService.getDefaultAgentConfig,
+      {
+        onSuccess: (data) => {
+          if (data) {
+            set(
+              {
+                defaultAgentConfig: merge(DEFAULT_AGENT_CONFIG, data),
+                isDefaultAgentConfigInit: true,
+              },
+              false,
+              'fetchDefaultAgentConfig',
+            );
+          }
+        },
+        revalidateOnFocus: false,
+      },
+    ),
 
   /* eslint-disable sort-keys-fix/sort-keys-fix */
 

package/src/store/agent/slices/chat/initialState.ts

@@ -1,14 +1,20 @@
+import { DeepPartial } from 'utility-types';
+
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { LobeAgentConfig } from '@/types/agent';
 
 export interface AgentState {
   activeId: string;
-  agentConfig: LobeAgentConfig;
+  agentConfig: DeepPartial<LobeAgentConfig>;
+  defaultAgentConfig: LobeAgentConfig;
   isAgentConfigInit: boolean;
+  isDefaultAgentConfigInit: boolean;
 }
 
-export const initialSessionState: AgentState = {
+export const initialAgentChatState: AgentState = {
   activeId: 'inbox',
-  agentConfig: DEFAULT_AGENT_CONFIG,
+  agentConfig: {},
+  defaultAgentConfig: DEFAULT_AGENT_CONFIG,
   isAgentConfigInit: false,
+  isDefaultAgentConfigInit: false,
 };

package/src/store/agent/slices/chat/selectors.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
+import { INBOX_SESSION_ID } from '@/const/session';
 import { DEFAULT_AGENT_CONFIG, DEFAUTT_AGENT_TTS_CONFIG } from '@/const/settings';
 import { AgentStore } from '@/store/agent';
 
@@ -76,7 +77,129 @@ describe('agentSelectors', () => {
     it('should return the appropriate TTS voice based on the service and language', () => {
       const lang = 'en';
       const ttsVoice = agentSelectors.currentAgentTTSVoice(lang)(mockSessionStore);
-      expect(ttsVoice).toBe(mockSessionStore.agentConfig.tts.voice.openai);
+      expect(ttsVoice).toBe(mockSessionStore.agentConfig.tts?.voice?.openai);
+    });
+
+    it('should return the default voice for edge TTS service', () => {
+      const modifiedStore = {
+        ...mockSessionStore,
+        agentConfig: {
+          ...mockSessionStore.agentConfig,
+          tts: {
+            ...DEFAUTT_AGENT_TTS_CONFIG,
+            ttsService: 'edge',
+          },
+        },
+      } as AgentStore;
+      const ttsVoice = agentSelectors.currentAgentTTSVoice('en')(modifiedStore);
+      expect(ttsVoice).toBe('ar-SA-HamedNeural');
+    });
+
+    it('should return the default voice for microsoft TTS service', () => {
+      const modifiedStore = {
+        ...mockSessionStore,
+        agentConfig: {
+          ...mockSessionStore.agentConfig,
+          tts: {
+            ...DEFAUTT_AGENT_TTS_CONFIG,
+            ttsService: 'microsoft',
+          },
+        },
+      } as AgentStore;
+      const ttsVoice = agentSelectors.currentAgentTTSVoice('en')(modifiedStore);
+      expect(ttsVoice).toBe('ar-SA-HamedNeural');
+    });
+
+    it('should return the first voice if the specified voice does not exist', () => {
+      const lang = 'en';
+      const modifiedStore = {
+        ...mockSessionStore,
+        agentConfig: {
+          ...mockSessionStore.agentConfig,
+          tts: {
+            ...DEFAUTT_AGENT_TTS_CONFIG,
+            ttsService: 'avc',
+            voice: {
+              openai: 'non-existent-voice',
+            },
+          },
+        },
+      };
+      const ttsVoice = agentSelectors.currentAgentTTSVoice(lang)(modifiedStore as any);
+      expect(ttsVoice).toBe('alloy');
+    });
+  });
+
+  describe('currentAgentModelProvider', () => {
+    it('should return the provider from the agent config', () => {
+      const provider = agentSelectors.currentAgentModelProvider(mockSessionStore);
+      expect(provider).toBe(mockSessionStore.agentConfig.provider);
+    });
+
+    it('should return undefined if provider is not defined in the agent config', () => {
+      const modifiedStore = {
+        ...mockSessionStore,
+        agentConfig: {
+          ...mockSessionStore.agentConfig,
+          provider: undefined,
+        },
+      };
+      const provider = agentSelectors.currentAgentModelProvider(modifiedStore);
+      expect(provider).toBeUndefined();
+    });
+  });
+
+  describe('currentAgentPlugins', () => {
+    it('should return the plugins array from the agent config', () => {
+      const plugins = agentSelectors.currentAgentPlugins(mockSessionStore);
+      expect(plugins).toEqual(mockSessionStore.agentConfig.plugins);
+    });
+
+    it('should return an empty array if plugins are not defined in the agent config', () => {
+      const modifiedStore = {
+        ...mockSessionStore,
+        agentConfig: {
+          ...mockSessionStore.agentConfig,
+          plugins: undefined,
+        },
+      };
+      const plugins = agentSelectors.currentAgentPlugins(modifiedStore);
+      expect(plugins).toEqual([]);
+    });
+  });
+
+  describe('currentAgentSystemRole', () => {
+    it('should return the system role from the agent config', () => {
+      const systemRole = agentSelectors.currentAgentSystemRole(mockSessionStore);
+      expect(systemRole).toBe(mockSessionStore.agentConfig.systemRole);
+    });
+
+    it('should return undefined if system role is not defined in the agent config', () => {
+      const modifiedStore = {
+        ...mockSessionStore,
+        agentConfig: {
+          ...mockSessionStore.agentConfig,
+          systemRole: undefined,
+        },
+      };
+      const systemRole = agentSelectors.currentAgentSystemRole(modifiedStore);
+      expect(systemRole).toBeUndefined();
+    });
+  });
+
+  describe('isInboxSession', () => {
+    it('should return true if activeId is INBOX_SESSION_ID', () => {
+      const modifiedStore = {
+        ...mockSessionStore,
+        activeId: INBOX_SESSION_ID,
+      };
+      const isInbox = agentSelectors.isInboxSession(modifiedStore);
+      expect(isInbox).toBe(true);
+    });
+
+    it('should return false if activeId is not INBOX_SESSION_ID', () => {
+      const isInbox = agentSelectors.isInboxSession(mockSessionStore);
+      expect(isInbox).toBe(false);
     });
   });
 });

package/src/store/agent/slices/chat/selectors.ts

@@ -1,15 +1,16 @@
 import { VoiceList } from '@lobehub/tts';
 
 import { INBOX_SESSION_ID } from '@/const/session';
-import { DEFAULT_AGENT_CONFIG, DEFAUTT_AGENT_TTS_CONFIG } from '@/const/settings';
+import { DEFAUTT_AGENT_TTS_CONFIG } from '@/const/settings';
 import { AgentStore } from '@/store/agent';
-import { LobeAgentTTSConfig } from '@/types/agent';
+import { LobeAgentConfig, LobeAgentTTSConfig } from '@/types/agent';
 import { merge } from '@/utils/merge';
 
 const isInboxSession = (s: AgentStore) => s.activeId === INBOX_SESSION_ID;
 
 // ==========   Config   ============== //
-const currentAgentConfig = (s: AgentStore) => merge(DEFAULT_AGENT_CONFIG, s.agentConfig);
+const currentAgentConfig = (s: AgentStore): LobeAgentConfig =>
+  merge(s.defaultAgentConfig, s.agentConfig);
 
 const currentAgentSystemRole = (s: AgentStore) => {
   return currentAgentConfig(s).systemRole;

package/src/app/api/config/route.test.ts

@@ -1,162 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { GlobalServerConfig } from '@/types/serverConfig';
-
-import { GET } from './route';
-
-beforeEach(() => {
-  vi.resetAllMocks();
-});
-
-describe('GET /api/config', () => {
-  describe('Model Provider env', () => {
-    describe('OPENAI_MODEL_LIST', () => {
-      it('custom deletion, addition, and renaming of models', async () => {
-        process.env.OPENAI_MODEL_LIST =
-          '-all,+llama,+claude-2，-gpt-3.5-turbo,gpt-4-0125-preview=gpt-4-turbo,gpt-4-0125-preview=gpt-4-32k';
-
-        const response = await GET();
-
-        // Assert
-        expect(response).toBeInstanceOf(Response);
-        expect(response.status).toBe(200);
-
-        const jsonResponse: GlobalServerConfig = await response.json();
-
-        const result = jsonResponse.languageModel?.openai;
-
-        expect(result).toMatchSnapshot();
-        process.env.OPENAI_MODEL_LIST = '';
-      });
-
-      it('should work correct with gpt-4', async () => {
-        process.env.OPENAI_MODEL_LIST =
-          '-all,+gpt-3.5-turbo-1106,+gpt-3.5-turbo,+gpt-3.5-turbo-16k,+gpt-4,+gpt-4-32k,+gpt-4-1106-preview,+gpt-4-vision-preview';
-
-        const response = await GET();
-        const jsonResponse: GlobalServerConfig = await response.json();
-
-        const result = jsonResponse.languageModel?.openai?.serverModelCards;
-
-        expect(result).toMatchSnapshot();
-
-        process.env.OPENAI_MODEL_LIST = '';
-      });
-
-      it('duplicate naming model', async () => {
-        process.env.OPENAI_MODEL_LIST =
-          'gpt-4-0125-preview=gpt-4-turbo，gpt-4-0125-preview=gpt-4-32k';
-
-        const response = await GET();
-        const jsonResponse: GlobalServerConfig = await response.json();
-
-        const result = jsonResponse.languageModel?.openai?.serverModelCards;
-
-        expect(result?.find((s) => s.id === 'gpt-4-0125-preview')?.displayName).toEqual(
-          'gpt-4-32k',
-        );
-
-        process.env.OPENAI_MODEL_LIST = '';
-      });
-
-      it('should delete model', async () => {
-        process.env.OPENAI_MODEL_LIST = '-gpt-4';
-
-        const res = await GET();
-        const data: GlobalServerConfig = await res.json();
-
-        const result = data.languageModel?.openai?.serverModelCards;
-
-        expect(result?.find((r) => r.id === 'gpt-4')).toBeUndefined();
-
-        process.env.OPENAI_MODEL_LIST = '';
-      });
-
-      it('show the hidden model', async () => {
-        process.env.OPENAI_MODEL_LIST = '+gpt-4-1106-preview';
-
-        const res = await GET();
-        const data: GlobalServerConfig = await res.json();
-
-        const result = data.languageModel?.openai?.serverModelCards;
-
-        expect(result?.find((o) => o.id === 'gpt-4-1106-preview')).toEqual({
-          displayName: 'GPT-4 Turbo Preview (1106)',
-          functionCall: true,
-          enabled: true,
-          id: 'gpt-4-1106-preview',
-          tokens: 128000,
-        });
-
-        process.env.OPENAI_MODEL_LIST = '';
-      });
-
-      it('only add the model', async () => {
-        process.env.OPENAI_MODEL_LIST = 'model1,model2,model3，model4';
-
-        const res = await GET();
-        const data: GlobalServerConfig = await res.json();
-
-        const result = data.languageModel?.openai?.serverModelCards;
-
-        expect(result).toContainEqual({
-          displayName: 'model1',
-          id: 'model1',
-          enabled: true,
-        });
-        expect(result).toContainEqual({
-          displayName: 'model2',
-          enabled: true,
-          id: 'model2',
-        });
-        expect(result).toContainEqual({
-          displayName: 'model3',
-          enabled: true,
-          id: 'model3',
-        });
-        expect(result).toContainEqual({
-          displayName: 'model4',
-          enabled: true,
-          id: 'model4',
-        });
-
-        process.env.OPENAI_MODEL_LIST = '';
-      });
-    });
-
-    describe('CUSTOM_MODELS', () => {
-      it('custom deletion, addition, and renaming of models', async () => {
-        process.env.CUSTOM_MODELS =
-          '-all,+llama,+claude-2，-gpt-3.5-turbo,gpt-4-0125-preview=gpt-4-turbo,gpt-4-0125-preview=gpt-4-32k';
-
-        const response = await GET();
-
-        // Assert
-        expect(response).toBeInstanceOf(Response);
-        expect(response.status).toBe(200);
-
-        const jsonResponse: GlobalServerConfig = await response.json();
-
-        const result = jsonResponse.languageModel?.openai?.serverModelCards;
-
-        expect(result).toMatchSnapshot();
-      });
-    });
-
-    describe('OPENROUTER_MODEL_LIST', () => {
-      it('custom deletion, addition, and renaming of models', async () => {
-        process.env.OPENROUTER_MODEL_LIST =
-          '-all,+google/gemma-7b-it,+mistralai/mistral-7b-instruct=Mistral-7B-Instruct';
-
-        const res = await GET();
-        const data: GlobalServerConfig = await res.json();
-
-        const result = data.languageModel?.openrouter;
-
-        expect(result).toMatchSnapshot();
-
-        process.env.OPENROUTER_MODEL_LIST = '';
-      });
-    });
-  });
-});

package/src/app/api/config/route.ts

@@ -1,118 +0,0 @@
-import {
-  OllamaProviderCard,
-  OpenAIProviderCard,
-  OpenRouterProviderCard,
-  TogetherAIProviderCard,
-} from '@/config/modelProviders';
-import { getServerConfig } from '@/config/server';
-import { GlobalServerConfig } from '@/types/serverConfig';
-import { extractEnabledModels, transformToChatModelCards } from '@/utils/parseModels';
-
-import { parseAgentConfig } from './parseDefaultAgent';
-
-export const runtime = 'edge';
-
-/**
- * get Server config to client
- */
-export const GET = async () => {
-  const {
-    ENABLE_LANGFUSE,
-    ENABLE_OAUTH_SSO,
-
-    DEFAULT_AGENT_CONFIG,
-    OPENAI_MODEL_LIST,
-
-    ENABLED_MOONSHOT,
-    ENABLED_ZHIPU,
-    ENABLED_AWS_BEDROCK,
-    ENABLED_GOOGLE,
-    ENABLED_GROQ,
-    ENABLED_PERPLEXITY,
-    ENABLED_ANTHROPIC,
-    ENABLED_MISTRAL,
-
-    ENABLED_AZURE_OPENAI,
-    AZURE_MODEL_LIST,
-
-    ENABLE_OLLAMA,
-    OLLAMA_MODEL_LIST,
-    OLLAMA_PROXY_URL,
-
-    ENABLED_OPENROUTER,
-    OPENROUTER_MODEL_LIST,
-
-    ENABLED_ZEROONE,
-    ENABLED_TOGETHERAI,
-    TOGETHERAI_MODEL_LIST,
-  } = getServerConfig();
-
-  const config: GlobalServerConfig = {
-    defaultAgent: {
-      config: parseAgentConfig(DEFAULT_AGENT_CONFIG),
-    },
-
-    enabledOAuthSSO: ENABLE_OAUTH_SSO,
-    languageModel: {
-      anthropic: {
-        enabled: ENABLED_ANTHROPIC,
-      },
-      azure: {
-        enabled: ENABLED_AZURE_OPENAI,
-        enabledModels: extractEnabledModels(AZURE_MODEL_LIST, true),
-        serverModelCards: transformToChatModelCards({
-          defaultChatModels: [],
-          modelString: AZURE_MODEL_LIST,
-          withDeploymentName: true,
-        }),
-      },
-      bedrock: { enabled: ENABLED_AWS_BEDROCK },
-      google: { enabled: ENABLED_GOOGLE },
-      groq: { enabled: ENABLED_GROQ },
-      mistral: { enabled: ENABLED_MISTRAL },
-      moonshot: { enabled: ENABLED_MOONSHOT },
-      ollama: {
-        enabled: ENABLE_OLLAMA,
-        fetchOnClient: !OLLAMA_PROXY_URL,
-        serverModelCards: transformToChatModelCards({
-          defaultChatModels: OllamaProviderCard.chatModels,
-          modelString: OLLAMA_MODEL_LIST,
-        }),
-      },
-      openai: {
-        enabledModels: extractEnabledModels(OPENAI_MODEL_LIST),
-        serverModelCards: transformToChatModelCards({
-          defaultChatModels: OpenAIProviderCard.chatModels,
-          modelString: OPENAI_MODEL_LIST,
-        }),
-      },
-
-      openrouter: {
-        enabled: ENABLED_OPENROUTER,
-        enabledModels: extractEnabledModels(OPENROUTER_MODEL_LIST),
-        serverModelCards: transformToChatModelCards({
-          defaultChatModels: OpenRouterProviderCard.chatModels,
-          modelString: OPENROUTER_MODEL_LIST,
-        }),
-      },
-      perplexity: { enabled: ENABLED_PERPLEXITY },
-
-      togetherai: {
-        enabled: ENABLED_TOGETHERAI,
-        enabledModels: extractEnabledModels(TOGETHERAI_MODEL_LIST),
-        serverModelCards: transformToChatModelCards({
-          defaultChatModels: TogetherAIProviderCard.chatModels,
-          modelString: TOGETHERAI_MODEL_LIST,
-        }),
-      },
-
-      zeroone: { enabled: ENABLED_ZEROONE },
-      zhipu: { enabled: ENABLED_ZHIPU },
-    },
-    telemetry: {
-      langfuse: ENABLE_LANGFUSE,
-    },
-  };
-
-  return new Response(JSON.stringify(config));
-};