@lobehub/chat 0.107.15 → 0.108.0

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 # Changelog
 
+## [Version 0.108.0](https://github.com/lobehub/lobe-chat/compare/v0.107.16...v0.108.0)
+
+<sup>Released on **2023-12-03**</sup>
+
+#### ✨ Features
+
+- **misc**: Hide the password form item in the settings when there is no `ACCESS_CODE` env.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Hide the password form item in the settings when there is no `ACCESS_CODE` env, closes [#568](https://github.com/lobehub/lobe-chat/issues/568) ([3b5f8b2](https://github.com/lobehub/lobe-chat/commit/3b5f8b2))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 0.107.16](https://github.com/lobehub/lobe-chat/compare/v0.107.15...v0.107.16)
+
+<sup>Released on **2023-12-03**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix custom agent meta issue.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix custom agent meta issue, closes [#567](https://github.com/lobehub/lobe-chat/issues/567) ([75560e1](https://github.com/lobehub/lobe-chat/commit/75560e1))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 0.107.15](https://github.com/lobehub/lobe-chat/compare/v0.107.14...v0.107.15)
 
 <sup>Released on **2023-12-03**</sup>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "0.107.15",
+  "version": "0.108.0",
   "description": "An open-source, extensible (Function Calling), high-performance chatbot framework. It supports one-click free deployment of your private ChatGPT/LLM web application",
   "keywords": [
     "chatbot",

package/src/app/chat/features/Conversation/ChatList/index.tsx

@@ -18,8 +18,8 @@ import SkeletonList from './SkeletonList';
 
 const List = memo(() => {
   const { t } = useTranslation('common');
-
-  const data = useChatStore(chatSelectors.currentChatsWithGuideMessage, isEqual);
+  const meta = useSessionStore(agentSelectors.currentAgentMeta, isEqual);
+  const data = useChatStore(chatSelectors.currentChatsWithGuideMessage(meta), isEqual);
 
   const [init, chatLoadingId, resendMessage, updateMessageContent] = useChatStore((s) => [
     s.messagesInit,

package/src/app/settings/(desktop)/index.tsx

@@ -6,14 +6,15 @@ import { FC, memo } from 'react';
 import ResponsiveIndex from '@/components/ResponsiveIndex';
 
 import Common from '../common';
+import { SettingsCommonProps } from '../common/Common';
 import Layout from './layout.desktop';
 
 const Mobile: FC = dynamic(() => import('../(mobile)'), { ssr: false }) as FC;
 
-export default memo(() => (
+export default memo<SettingsCommonProps>((props) => (
   <ResponsiveIndex Mobile={Mobile}>
     <Layout>
-      <Common />
+      <Common {...props} />
     </Layout>
   </ResponsiveIndex>
 ));

package/src/app/settings/common/Common.tsx

@@ -21,7 +21,11 @@ import { ThemeSwatchesNeutral, ThemeSwatchesPrimary } from '../features/ThemeSwa
 
 type SettingItemGroup = ItemGroup;
 
-const Common = memo(() => {
+export interface SettingsCommonProps {
+  showAccessCodeConfig: boolean;
+}
+
+const Common = memo<SettingsCommonProps>(({ showAccessCodeConfig }) => {
   const { t } = useTranslation('setting');
   const [form] = AntForm.useForm();
 
@@ -154,6 +158,7 @@ const Common = memo(() => {
       {
         children: <Input.Password placeholder={t('settingSystem.accessCode.placeholder')} />,
         desc: t('settingSystem.accessCode.desc'),
+        hidden: !showAccessCodeConfig,
         label: t('settingSystem.accessCode.title'),
         name: 'password',
       },

package/src/app/settings/common/index.tsx

@@ -9,16 +9,16 @@ import { useSwitchSideBarOnInit } from '@/store/global/hooks/useSwitchSettingsOn
 import { SettingsTabs } from '@/store/global/initialState';
 
 import Footer from '../features/Footer';
-import Common from './Common';
+import Common, { SettingsCommonProps } from './Common';
 
-export default memo(() => {
+export default memo<SettingsCommonProps>((props) => {
   useSwitchSideBarOnInit(SettingsTabs.Common);
   const { t } = useTranslation('setting');
 
   return (
     <>
       <PageTitle title={t('tab.common')} />
-      <Common />
+      <Common {...props} />
       <Footer>LobeChat v{CURRENT_VERSION}</Footer>
     </>
   );

package/src/app/settings/common/page.tsx

@@ -1,3 +1,9 @@
+import { getServerConfig } from '@/config/server';
+
 import Index from './index';
 
-export default () => <Index />;
+export default () => {
+  const { SHOW_ACCESS_CODE_CONFIG } = getServerConfig();
+
+  return <Index showAccessCodeConfig={SHOW_ACCESS_CODE_CONFIG} />;
+};

package/src/app/settings/page.tsx

@@ -1,3 +1,4 @@
+import { getServerConfig } from '@/config/server';
 import { isMobileDevice } from '@/utils/responsive';
 
 import DesktopPage from './(desktop)';
@@ -8,7 +9,9 @@ const Page = () => {
 
   const Page = mobile ? MobilePage : DesktopPage;
 
-  return <Page />;
+  const { SHOW_ACCESS_CODE_CONFIG } = getServerConfig();
+
+  return <Page showAccessCodeConfig={SHOW_ACCESS_CODE_CONFIG} />;
 };
 
 export default Page;

package/src/config/server.ts

@@ -33,8 +33,12 @@ export const getServerConfig = () => {
     regions = process.env.OPENAI_FUNCTION_REGIONS.split(',');
   }
 
+  const ACCESS_CODE = process.env.ACCESS_CODE;
+
   return {
-    ACCESS_CODE: process.env.ACCESS_CODE,
+    ACCESS_CODE,
+
+    SHOW_ACCESS_CODE_CONFIG: !!ACCESS_CODE,
 
     OPENAI_API_KEY: process.env.OPENAI_API_KEY,
     OPENAI_PROXY_URL: process.env.OPENAI_PROXY_URL,

package/src/store/chat/actions/enhance.ts

@@ -10,7 +10,7 @@ import { chatSelectors } from '@/store/chat/selectors';
 import { ChatStore } from '@/store/chat/store';
 import { setNamespace } from '@/utils/storeDebug';
 
-const t = setNamespace('enhance');
+const n = setNamespace('enhance');
 
 /**
  * enhance chat action like translate,tts
@@ -49,7 +49,7 @@ export const chatEnhance: StateCreator<
     await messageService.updateMessageTranslate(id, { content: '', from: '', to: targetLang });
     await refreshMessages();
 
-    toggleChatLoading(true, id, t('translateMessage(start)', { id }) as string);
+    toggleChatLoading(true, id, n('translateMessage(start)', { id }) as string);
 
     let content = '';
     let from = '';

package/src/store/chat/actions/message.ts

@@ -25,7 +25,7 @@ import { setNamespace } from '@/utils/storeDebug';
 import { MessageDispatch, messagesReducer } from '../reducers/message';
 import { chatSelectors } from '../selectors';
 
-const t = setNamespace('message');
+const n = setNamespace('message');
 
 export interface ChatMessageAction {
   // create
@@ -191,10 +191,10 @@ export const chatMessage: StateCreator<
 
     abortController.abort();
 
-    toggleChatLoading(false, undefined, t('stopGenerateMessage') as string);
+    toggleChatLoading(false, undefined, n('stopGenerateMessage') as string);
   },
   updateInputMessage: (message) => {
-    set({ inputMessage: message }, false, t('updateInputMessage', message));
+    set({ inputMessage: message }, false, n('updateInputMessage', message));
   },
   updateMessageContent: async (id, content) => {
     const { dispatchMessage, refreshMessages } = get();
@@ -217,7 +217,7 @@ export const chatMessage: StateCreator<
           set(
             { activeId: sessionId, messages, messagesInit: true },
             false,
-            t('useFetchMessages', {
+            n('useFetchMessages', {
               messages,
               queryKey: key,
             }),
@@ -291,7 +291,7 @@ export const chatMessage: StateCreator<
 
     const messages = messagesReducer(get().messages, payload);
 
-    set({ messages }, false, t(`dispatchMessage/${payload.type}`, payload));
+    set({ messages }, false, n(`dispatchMessage/${payload.type}`, payload));
   },
   fetchAIChatMessage: async (messages, assistantId) => {
     const { toggleChatLoading, refreshMessages } = get();
@@ -299,7 +299,7 @@ export const chatMessage: StateCreator<
     const abortController = toggleChatLoading(
       true,
       assistantId,
-      t('generateMessage(start)', { assistantId, messages }) as string,
+      n('generateMessage(start)', { assistantId, messages }) as string,
     );
 
     const config = getAgentConfig();
@@ -380,7 +380,7 @@ export const chatMessage: StateCreator<
       },
     });
 
-    toggleChatLoading(false, undefined, t('generateMessage(end)') as string);
+    toggleChatLoading(false, undefined, n('generateMessage(end)') as string);
 
     // also exist message like this:
     // 请稍等，我帮您查询一下。{"function_call": {"name": "plugin-identifier____recommendClothes____standalone", "arguments": "{\n "mood": "",\n "gender": "man"\n}"}}

package/src/store/chat/actions/plugin.ts

@@ -10,7 +10,7 @@ import { setNamespace } from '@/utils/storeDebug';
 
 import { chatSelectors } from '../selectors';
 
-const t = setNamespace('plugin');
+const n = setNamespace('plugin');
 
 export interface ChatPluginAction {
   fillPluginMessageContent: (id: string, content: string) => Promise<void>;
@@ -38,7 +38,7 @@ export const chatPlugin: StateCreator<
     const { refreshMessages, coreProcessMessage, toggleChatLoading } = get();
     let data: string;
     try {
-      const abortController = toggleChatLoading(true, id, t('fetchPlugin') as string);
+      const abortController = toggleChatLoading(true, id, n('fetchPlugin') as string);
       data = await chatService.runPluginApi(payload, { signal: abortController?.signal });
     } catch (error) {
       await messageService.updateMessageError(id, error as any);

package/src/store/chat/actions/topic.test.ts

@@ -0,0 +1,391 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { mutate } from 'swr';
+import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { LOADING_FLAT } from '@/const/message';
+import { chatService } from '@/services/chat';
+import { messageService } from '@/services/message';
+import { topicService } from '@/services/topic';
+import { ChatMessage } from '@/types/chatMessage';
+import { ChatTopic } from '@/types/topic';
+
+import { useChatStore } from '../store';
+
+// Mock topicService 和 messageService
+vi.mock('@/services/topic', () => ({
+  topicService: {
+    removeTopics: vi.fn(),
+    removeAllTopic: vi.fn(),
+    removeTopic: vi.fn(),
+    createTopic: vi.fn(),
+    updateTitle: vi.fn(),
+    updateFavorite: vi.fn(),
+    batchRemoveTopics: vi.fn(),
+    getTopics: vi.fn(),
+    searchTopics: vi.fn(),
+  },
+}));
+
+vi.mock('@/services/message', () => ({
+  messageService: {
+    removeMessages: vi.fn(),
+  },
+}));
+
+beforeEach(() => {
+  // Setup initial state and mocks before each test
+  vi.clearAllMocks();
+  useChatStore.setState(
+    {
+      activeId: undefined,
+      activeTopicId: undefined,
+      // ... initial state
+    },
+    false,
+  );
+});
+
+afterEach(() => {
+  // Cleanup mocks after each test
+  vi.restoreAllMocks();
+});
+
+describe('topic action', () => {
+  describe('openNewTopicOrSaveTopic', () => {
+    it('should call switchTopic if activeTopicId exists', async () => {
+      const { result } = renderHook(() => useChatStore());
+      await act(async () => {
+        useChatStore.setState({ activeTopicId: 'existing-topic-id' });
+      });
+
+      const switchTopicSpy = vi.spyOn(result.current, 'switchTopic');
+
+      await act(async () => {
+        result.current.openNewTopicOrSaveTopic();
+      });
+
+      expect(switchTopicSpy).toHaveBeenCalled();
+    });
+
+    it('should call saveToTopic if activeTopicId does not exist', async () => {
+      const { result } = renderHook(() => useChatStore());
+      await act(async () => {
+        useChatStore.setState({ activeTopicId: '' });
+      });
+
+      const saveToTopicSpy = vi.spyOn(result.current, 'saveToTopic');
+
+      await act(async () => {
+        await result.current.openNewTopicOrSaveTopic();
+      });
+
+      expect(saveToTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('saveToTopic', () => {
+    it('should not create a topic if there are no messages', async () => {
+      const { result } = renderHook(() => useChatStore());
+      useChatStore.setState({ messages: [] });
+
+      const createTopicSpy = vi.spyOn(topicService, 'createTopic');
+
+      const topicId = await result.current.saveToTopic();
+
+      expect(createTopicSpy).not.toHaveBeenCalled();
+      expect(topicId).toBeUndefined();
+    });
+
+    it('should create a topic and bind messages to it', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const messages = [{ id: 'message1' }, { id: 'message2' }] as ChatMessage[];
+      useChatStore.setState({ messages, activeId: 'session-id' });
+
+      const createTopicSpy = vi
+        .spyOn(topicService, 'createTopic')
+        .mockResolvedValue('new-topic-id');
+
+      const topicId = await result.current.saveToTopic();
+
+      expect(createTopicSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionId: 'session-id',
+          messages: messages.map((m) => m.id),
+        }),
+      );
+      expect(topicId).toEqual('new-topic-id');
+    });
+  });
+  describe('refreshTopic', () => {
+    beforeEach(() => {
+      vi.mock('swr', async () => {
+        const actual = await vi.importActual('swr');
+        return {
+          ...(actual as any),
+          mutate: vi.fn(),
+        };
+      });
+    });
+    afterEach(() => {
+      // 在每个测试用例开始前恢复到实际的 SWR 实现
+      vi.resetAllMocks();
+    });
+
+    it('should call mutate to refresh topics', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const activeId = 'test-session-id';
+      useChatStore.setState({ activeId });
+
+      // Mock the mutate function to resolve immediately
+
+      await act(async () => {
+        await result.current.refreshTopic();
+      });
+
+      // Check if mutate has been called with the active session ID
+      expect(mutate).toHaveBeenCalledWith(activeId);
+    });
+
+    it('should handle errors during refreshing topics', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const activeId = 'test-session-id';
+      useChatStore.setState({ activeId });
+
+      // Mock the mutate function to throw an error
+      // 设置模拟错误
+      (mutate as Mock).mockImplementation(() => {
+        throw new Error('Mutate error');
+      });
+
+      await act(async () => {
+        await expect(result.current.refreshTopic()).rejects.toThrow('Mutate error');
+      });
+
+      // 确保恢复 mutate 的模拟，以免影响其他测试
+      (mutate as Mock).mockReset();
+    });
+
+    // Additional tests for refreshTopic can be added here...
+  });
+  describe('favoriteTopic', () => {
+    it('should update the favorite state of a topic and refresh topics', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const topicId = 'topic-id';
+      const favState = true;
+
+      const updateFavoriteSpy = vi.spyOn(topicService, 'updateFavorite').mockResolvedValue(true);
+
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+
+      await act(async () => {
+        await result.current.favoriteTopic(topicId, favState);
+      });
+
+      expect(updateFavoriteSpy).toHaveBeenCalledWith(topicId, favState);
+      expect(refreshTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('useFetchTopics', () => {
+    it('should fetch topics for a given session id', async () => {
+      const sessionId = 'test-session-id';
+      const topics = [{ id: 'topic-id', title: 'Test Topic' }];
+
+      // Mock the topicService.getTopics to resolve with topics array
+      (topicService.getTopics as Mock).mockResolvedValue(topics);
+
+      // Use the hook with the session id
+      const { result } = renderHook(() => useChatStore().useFetchTopics(sessionId));
+
+      // Wait for the hook to resolve and update the state
+      await waitFor(() => {
+        expect(result.current.data).toEqual(topics);
+      });
+      expect(useChatStore.getState().topicsInit).toBeTruthy();
+      expect(useChatStore.getState().topics).toEqual(topics);
+    });
+  });
+  describe('useSearchTopics', () => {
+    it('should search topics with the given keywords', async () => {
+      const keywords = 'search-term';
+      const searchResults = [{ id: 'searched-topic-id', title: 'Searched Topic' }];
+
+      // Mock the topicService.searchTopics to resolve with search results
+      (topicService.searchTopics as Mock).mockResolvedValue(searchResults);
+
+      // Use the hook with the keywords
+      const { result } = renderHook(() => useChatStore().useSearchTopics(keywords));
+
+      // Wait for the hook to resolve and update the state
+      await waitFor(() => {
+        expect(result.current.data).toEqual(searchResults);
+      });
+    });
+  });
+  describe('updateTopicTitle', () => {
+    it('should call topicService.updateTitle with correct parameters and refresh the topic', async () => {
+      const topicId = 'topic-id';
+      const newTitle = 'Updated Topic Title';
+      // Mock the topicService.updateTitle to resolve immediately
+      (topicService.updateTitle as Mock).mockResolvedValue(undefined);
+
+      const { result } = renderHook(() => useChatStore());
+
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+
+      // Call the action with the topicId and newTitle
+      await act(async () => {
+        await result.current.updateTopicTitle(topicId, newTitle);
+      });
+
+      // Verify that the topicService.updateTitle was called with correct parameters
+      expect(topicService.updateTitle).toHaveBeenCalledWith(topicId, newTitle);
+
+      // Verify that the refreshTopic was called to update the state
+      expect(refreshTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('switchTopic', () => {
+    it('should update activeTopicId and call refreshMessages', async () => {
+      const topicId = 'topic-id';
+      const { result } = renderHook(() => useChatStore());
+
+      const refreshMessagesSpy = vi.spyOn(result.current, 'refreshMessages');
+      // Call the switchTopic action with the topicId
+      await act(async () => {
+        await result.current.switchTopic(topicId);
+      });
+
+      // Verify that the activeTopicId has been updated
+      expect(useChatStore.getState().activeTopicId).toBe(topicId);
+
+      // Verify that the refreshMessages was called to update the messages
+      expect(refreshMessagesSpy).toHaveBeenCalled();
+    });
+  });
+  describe('removeSessionTopics', () => {
+    it('should remove all topics from the current session and refresh the topic list', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const activeId = 'test-session-id';
+      await act(async () => {
+        useChatStore.setState({ activeId });
+      });
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+      const switchTopicSpy = vi.spyOn(result.current, 'switchTopic');
+
+      await act(async () => {
+        await result.current.removeSessionTopics();
+      });
+
+      expect(topicService.removeTopics).toHaveBeenCalledWith(activeId);
+      expect(refreshTopicSpy).toHaveBeenCalled();
+      expect(switchTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('removeAllTopics', () => {
+    it('should remove all topics and refresh the topic list', async () => {
+      const { result } = renderHook(() => useChatStore());
+
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+
+      await act(async () => {
+        await result.current.removeAllTopics();
+      });
+
+      expect(topicService.removeAllTopic).toHaveBeenCalled();
+      expect(refreshTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('removeTopic', () => {
+    it('should remove a specific topic and its messages, then refresh the topic list', async () => {
+      const topicId = 'topic-1';
+      const { result } = renderHook(() => useChatStore());
+      const activeId = 'test-session-id';
+
+      await act(async () => {
+        useChatStore.setState({ activeId });
+      });
+
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+      const switchTopicSpy = vi.spyOn(result.current, 'switchTopic');
+
+      await act(async () => {
+        await result.current.removeTopic(topicId);
+      });
+
+      expect(messageService.removeMessages).toHaveBeenCalledWith(activeId, topicId);
+      expect(topicService.removeTopic).toHaveBeenCalledWith(topicId);
+      expect(refreshTopicSpy).toHaveBeenCalled();
+      expect(switchTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('removeUnstarredTopic', () => {
+    it('should remove unstarred topics and refresh the topic list', async () => {
+      const { result } = renderHook(() => useChatStore());
+      // Set up mock state with unstarred topics
+      await act(async () => {
+        useChatStore.setState({
+          topics: [
+            { id: 'topic-1', favorite: false },
+            { id: 'topic-2', favorite: true },
+            { id: 'topic-3', favorite: false },
+          ] as ChatTopic[],
+        });
+      });
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+      const switchTopicSpy = vi.spyOn(result.current, 'switchTopic');
+
+      await act(async () => {
+        await result.current.removeUnstarredTopic();
+      });
+
+      expect(topicService.batchRemoveTopics).toHaveBeenCalledWith(['topic-1', 'topic-3']);
+      expect(refreshTopicSpy).toHaveBeenCalled();
+      expect(switchTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('updateTopicLoading', () => {
+    it('should call update topicLoadingId', async () => {
+      const { result } = renderHook(() => useChatStore());
+      expect(result.current.topicLoadingId).toBeUndefined();
+
+      // Call the action with the topicId and newTitle
+      await act(async () => {
+        await result.current.updateTopicLoading('loading-id');
+      });
+
+      expect(result.current.topicLoadingId).toEqual('loading-id');
+    });
+  });
+  describe('summaryTopicTitle', () => {
+    it('should auto-summarize the topic title and update it', async () => {
+      const topicId = 'topic-1';
+      const messages = [{ id: 'message-1', content: 'Hello' }] as ChatMessage[];
+      const topics = [{ id: 'topic-1', title: 'Test Topic' }] as ChatTopic[];
+      const { result } = renderHook(() => useChatStore());
+      await act(async () => {
+        useChatStore.setState({ topics });
+      });
+
+      // Mock the `updateTopicTitleInSummary` and `refreshTopic` for spying
+      const updateTopicTitleInSummarySpy = vi.spyOn(result.current, 'updateTopicTitleInSummary');
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+
+      // Mock the `chatService.fetchPresetTaskResult` to simulate the AI response
+      vi.spyOn(chatService, 'fetchPresetTaskResult').mockImplementation((params) => {
+        if (params) {
+          params.onFinish?.('Summarized Title');
+        }
+        return Promise.resolve(undefined);
+      });
+
+      await act(async () => {
+        await result.current.summaryTopicTitle(topicId, messages);
+      });
+
+      // Verify that the title was updated and the topic was refreshed
+      expect(updateTopicTitleInSummarySpy).toHaveBeenCalledWith(topicId, LOADING_FLAT);
+      expect(refreshTopicSpy).toHaveBeenCalled();
+
+      // TODO: need to test with fetchPresetTaskResult
+    });
+  });
+});

package/src/store/chat/actions/topic.ts

@@ -22,7 +22,7 @@ const n = setNamespace('topic');
 
 export interface ChatTopicAction {
   favoriteTopic: (id: string, favState: boolean) => Promise<void>;
-  openNewTopicOrSaveTopic: () => void;
+  openNewTopicOrSaveTopic: () => Promise<void>;
   refreshTopic: () => Promise<void>;
   removeAllTopics: () => Promise<void>;
   removeSessionTopics: () => Promise<void>;
@@ -45,7 +45,7 @@ export const chatTopic: StateCreator<
   ChatTopicAction
 > = (set, get) => ({
   // create
-  openNewTopicOrSaveTopic: () => {
+  openNewTopicOrSaveTopic: async () => {
     const { switchTopic, saveToTopic, activeTopicId } = get();
     const hasTopic = !!activeTopicId;