@lobehub/chat 0.159.11 → 0.159.12

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

@@ -1,6 +1,7 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
 // Disable the auto sort key eslint rule to make the code more logic and readable
 import { copyToClipboard } from '@lobehub/ui';
+import isEqual from 'fast-deep-equal';
 import { produce } from 'immer';
 import { template } from 'lodash-es';
 import { SWRResponse, mutate } from 'swr';
@@ -16,16 +17,17 @@ import { traceService } from '@/services/trace';
 import { useAgentStore } from '@/store/agent';
 import { agentSelectors } from '@/store/agent/selectors';
 import { chatHelpers } from '@/store/chat/helpers';
+import { messageMapKey } from '@/store/chat/slices/message/utils';
 import { ChatStore } from '@/store/chat/store';
 import { ChatMessage, MessageToolCall } from '@/types/message';
 import { TraceEventPayloads } from '@/types/trace';
 import { setNamespace } from '@/utils/storeDebug';
 import { nanoid } from '@/utils/uuid';
 
-import { chatSelectors } from '../../selectors';
+import { chatSelectors, topicSelectors } from '../../selectors';
 import { MessageDispatch, messagesReducer } from './reducer';
 
-const n = setNamespace('message');
+const n = setNamespace('m');
 
 const SWR_USE_FETCH_MESSAGES = 'SWR_USE_FETCH_MESSAGES';
 
@@ -121,7 +123,12 @@ export interface ChatMessageAction {
     content: string,
     toolCalls?: MessageToolCall[],
   ) => Promise<void>;
-  internal_createMessage: (params: CreateMessageParams) => Promise<string>;
+  internal_createMessage: (
+    params: CreateMessageParams,
+    context?: { tempMessageId?: string; skipRefresh?: boolean },
+  ) => Promise<string>;
+  internal_createTmpMessage: (params: CreateMessageParams) => string;
+  internal_fetchMessages: () => Promise<void>;
   internal_resendMessage: (id: string, traceId?: string) => Promise<void>;
   internal_traceMessage: (id: string, payload: TraceEventPayloads) => Promise<void>;
 }
@@ -166,7 +173,9 @@ export const chatMessage: StateCreator<
     if (message.tools) {
       const pools = message.tools
         .flatMap((tool) => {
-          const messages = get().messages.filter((m) => m.tool_call_id === tool.id);
+          const messages = chatSelectors
+            .currentChats(get())
+            .filter((m) => m.tool_call_id === tool.id);
 
           return messages.map((m) => m.id);
         })
@@ -218,8 +227,10 @@ export const chatMessage: StateCreator<
 
     const fileIdList = files?.map((f) => f.id);
 
-    // if message is empty and no files, then stop
-    if (!message && (!fileIdList || fileIdList?.length === 0)) return;
+    const isNoFile = !fileIdList || fileIdList.length === 0;
+
+    // if message is empty or no files, then stop
+    if (!message && isNoFile) return;
 
     const newMessage: CreateMessageParams = {
       content: message,
@@ -231,27 +242,91 @@ export const chatMessage: StateCreator<
       topicId: activeTopicId,
     };
 
-    const id = await get().internal_createMessage(newMessage);
+    const agentConfig = getAgentConfig();
+
+    let tempMessageId: string | undefined = undefined;
+    let newTopicId: string | undefined = undefined;
+
+    // it should be the default topic, then
+    // if autoCreateTopic is enabled, check to whether we need to create a topic
+    if (!onlyAddUserMessage && !activeTopicId && agentConfig.enableAutoCreateTopic) {
+      // check activeTopic and then auto create topic
+      const chats = chatSelectors.currentChats(get());
+
+      // we will add two messages (user and assistant), so the finial length should +2
+      const featureLength = chats.length + 2;
+
+      // if there is no activeTopicId and the feature length is greater than the threshold
+      // then create a new topic and active it
+      if (!get().activeTopicId && featureLength >= agentConfig.autoCreateTopicThreshold) {
+        // we need to create a temp message for optimistic update
+        tempMessageId = get().internal_createTmpMessage(newMessage);
+        get().internal_toggleMessageLoading(true, tempMessageId);
+
+        const topicId = await get().createTopic();
+
+        if (topicId) {
+          newTopicId = topicId;
+          newMessage.topicId = topicId;
+
+          // we need to copy the messages to the new topic or the message will disappear
+          const mapKey = chatSelectors.currentChatKey(get());
+          const newMaps = {
+            ...get().messagesMap,
+            [messageMapKey(activeId, topicId)]: get().messagesMap[mapKey],
+          };
+          set({ messagesMap: newMaps }, false, 'internal_copyMessages');
+
+          // get().internal_dispatchMessage({ type: 'deleteMessage', id: tempMessageId });
+          get().internal_toggleMessageLoading(false, tempMessageId);
+
+          // make the topic loading
+          get().internal_updateTopicLoading(topicId, true);
+        }
+      }
+    }
+
+    const id = await get().internal_createMessage(newMessage, {
+      tempMessageId,
+      skipRefresh: !onlyAddUserMessage,
+    });
+
+    // switch to the new topic if create the new topic
+    if (!!newTopicId) {
+      await get().switchTopic(newTopicId, true);
+      await get().internal_fetchMessages();
+
+      // delete previous messages
+      // remove the temp message map
+      const newMaps = { ...get().messagesMap, [messageMapKey(activeId, null)]: [] };
+      set({ messagesMap: newMaps }, false, 'internal_copyMessages');
+    }
 
     // if only add user message, then stop
-    if (onlyAddUserMessage) return;
+    if (onlyAddUserMessage) {
+      return;
+    }
 
     // Get the current messages to generate AI response
     const messages = chatSelectors.currentChats(get());
 
     await internal_coreProcessMessage(messages, id, { isWelcomeQuestion });
 
-    // check activeTopic and then auto create topic
-    const chats = chatSelectors.currentChats(get());
-
-    const agentConfig = getAgentConfig();
     // if autoCreateTopic is false, then stop
     if (!agentConfig.enableAutoCreateTopic) return;
 
-    if (!activeTopicId && chats.length >= agentConfig.autoCreateTopicThreshold) {
-      const { saveToTopic, switchTopic } = get();
-      const id = await saveToTopic();
-      if (id) switchTopic(id);
+    // check activeTopic and then auto update topic title
+    if (newTopicId) {
+      const chats = chatSelectors.currentChats(get());
+      await get().summaryTopicTitle(newTopicId, chats);
+      return;
+    }
+
+    const topic = topicSelectors.currentActiveTopic(get());
+
+    if (topic && !topic.title) {
+      const chats = chatSelectors.currentChats(get());
+      await get().summaryTopicTitle(topic.id, chats);
     }
   },
   addAIMessage: async () => {
@@ -289,7 +364,10 @@ export const chatMessage: StateCreator<
 
     internal_toggleChatLoading(false, undefined, n('stopGenerateMessage') as string);
   },
+
   updateInputMessage: (message) => {
+    if (isEqual(message, get().inputMessage)) return;
+
     set({ inputMessage: message }, false, n('updateInputMessage', message));
   },
   modifyMessageContent: async (id, content) => {
@@ -308,16 +386,18 @@ export const chatMessage: StateCreator<
       async ([, sessionId, topicId]: [string, string, string | undefined]) =>
         messageService.getMessages(sessionId, topicId),
       {
-        suspense: true,
-        fallbackData: [],
         onSuccess: (messages, key) => {
+          const nextMap = {
+            ...get().messagesMap,
+            [messageMapKey(sessionId, activeTopicId)]: messages,
+          };
+          // no need to update map if the messages have been init and the map is the same
+          if (get().messagesInit && isEqual(nextMap, get().messagesMap)) return;
+
           set(
-            { activeId: sessionId, messages, messagesInit: true },
+            { messagesInit: true, messagesMap: nextMap },
             false,
-            n('useFetchMessages', {
-              messages,
-              queryKey: key,
-            }),
+            n('useFetchMessages', { messages, queryKey: key }),
           );
         },
       },
@@ -360,9 +440,13 @@ export const chatMessage: StateCreator<
 
     if (!activeId) return;
 
-    const messages = messagesReducer(get().messages, payload);
+    const messages = messagesReducer(chatSelectors.currentChats(get()), payload);
+
+    const nextMap = { ...get().messagesMap, [chatSelectors.currentChatKey(get())]: messages };
 
-    set({ messages }, false, { type: `dispatchMessage/${payload.type}`, payload });
+    if (isEqual(nextMap, get().messagesMap)) return;
+
+    set({ messagesMap: nextMap }, false, { type: `dispatchMessage/${payload.type}`, payload });
   },
   internal_fetchAIChatMessage: async (messages, assistantId, params) => {
     const {
@@ -616,22 +700,49 @@ export const chatMessage: StateCreator<
     await refreshMessages();
   },
 
-  internal_createMessage: async (message) => {
-    const { internal_dispatchMessage, refreshMessages, internal_toggleMessageLoading } = get();
+  internal_createMessage: async (message, context) => {
+    const { internal_createTmpMessage, refreshMessages, internal_toggleMessageLoading } = get();
+    let tempId = context?.tempMessageId;
 
-    // use optimistic update to avoid the slow waiting
-    const tempId = 'tmp_' + nanoid();
-    internal_dispatchMessage({ type: 'createMessage', id: tempId, value: message });
+    if (!tempId) {
+      // use optimistic update to avoid the slow waiting
+      tempId = internal_createTmpMessage(message);
+
+      internal_toggleMessageLoading(true, tempId);
+    }
 
-    internal_toggleMessageLoading(true, tempId);
     const id = await messageService.createMessage(message);
+    if (!context?.skipRefresh) {
+      await refreshMessages();
+    }
 
-    await refreshMessages();
     internal_toggleMessageLoading(false, tempId);
 
     return id;
   },
 
+  internal_fetchMessages: async () => {
+    const messages = await messageService.getMessages(get().activeId, get().activeTopicId);
+    const nextMap = { ...get().messagesMap, [chatSelectors.currentChatKey(get())]: messages };
+    // no need to update map if the messages have been init and the map is the same
+    if (get().messagesInit && isEqual(nextMap, get().messagesMap)) return;
+
+    set(
+      { messagesInit: true, messagesMap: nextMap },
+      false,
+      n('internal_fetchMessages', { messages }),
+    );
+  },
+  internal_createTmpMessage: (message) => {
+    const { internal_dispatchMessage } = get();
+
+    // use optimistic update to avoid the slow waiting
+    const tempId = 'tmp_' + nanoid();
+    internal_dispatchMessage({ type: 'createMessage', id: tempId, value: message });
+
+    return tempId;
+  },
+
   internal_traceMessage: async (id, payload) => {
     // tracing the diff of update
     const message = chatSelectors.getMessageById(id)(get());

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

@@ -20,11 +20,11 @@ export interface ChatMessageState {
    * is the message is creating or updating in the service
    */
   messageLoadingIds: string[];
-  messages: ChatMessage[];
   /**
    * whether messages have fetched
    */
   messagesInit: boolean;
+  messagesMap: Record<string, ChatMessage[]>;
   /**
    * the tool calling stream ids
    */
@@ -37,7 +37,7 @@ export const initialMessageState: ChatMessageState = {
   inputMessage: '',
   messageEditingIds: [],
   messageLoadingIds: [],
-  messages: [],
   messagesInit: false,
+  messagesMap: {},
   toolCallingStreamIds: {},
 };

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

@@ -6,6 +6,7 @@ import { INBOX_SESSION_ID } from '@/const/session';
 import { useAgentStore } from '@/store/agent';
 import { ChatStore } from '@/store/chat';
 import { initialState } from '@/store/chat/initialState';
+import { messageMapKey } from '@/store/chat/slices/message/utils';
 import { useSessionStore } from '@/store/session';
 import { useUserStore } from '@/store/user';
 import { LobeAgentConfig } from '@/types/agent';
@@ -87,7 +88,12 @@ const mockedChats = [
   },
 ] as ChatMessage[];
 
-const mockChatStore = { messages: mockMessages } as ChatStore;
+const mockChatStore = {
+  messagesMap: {
+    [messageMapKey('abc')]: mockMessages,
+  },
+  activeId: 'abc',
+} as ChatStore;
 
 describe('chatSelectors', () => {
   describe('getMessageById', () => {
@@ -97,14 +103,19 @@ describe('chatSelectors', () => {
     });
 
     it('should return the message object with the matching id', () => {
-      const state = merge(initialStore, { messages: mockMessages });
+      const state = merge(initialStore, {
+        messagesMap: {
+          [messageMapKey('abc')]: mockMessages,
+        },
+        activeId: 'abc',
+      });
       const message = chatSelectors.getMessageById('msg1')(state);
-      expect(message).toEqual(mockMessages[0]);
+      expect(message).toEqual(mockedChats[0]);
     });
 
     it('should return the message with the matching id', () => {
       const message = chatSelectors.getMessageById('msg1')(mockChatStore);
-      expect(message).toEqual(mockMessages[0]);
+      expect(message).toEqual(mockedChats[0]);
     });
 
     it('should return undefined if no message matches the id', () => {
@@ -115,14 +126,24 @@ describe('chatSelectors', () => {
 
   describe('currentChatsWithHistoryConfig', () => {
     it('should slice the messages according to the current agent config', () => {
-      const state = merge(initialStore, { messages: mockMessages });
+      const state = merge(initialStore, {
+        messagesMap: {
+          [messageMapKey('abc')]: mockMessages,
+        },
+        activeId: 'abc',
+      });
 
       const chats = chatSelectors.currentChatsWithHistoryConfig(state);
       expect(chats).toHaveLength(3);
       expect(chats).toEqual(mockedChats);
     });
     it('should slice the messages according to config, assuming historyCount is mocked to 2', async () => {
-      const state = merge(initialStore, { messages: mockMessages });
+      const state = merge(initialStore, {
+        messagesMap: {
+          [messageMapKey('abc')]: mockMessages,
+        },
+        activeId: 'abc',
+      });
       act(() => {
         useAgentStore.setState({
           activeId: 'inbox',
@@ -172,7 +193,12 @@ describe('chatSelectors', () => {
 
   describe('currentChatsWithGuideMessage', () => {
     it('should return existing messages if there are any', () => {
-      const state = merge(initialStore, { messages: mockMessages, activeId: 'someActiveId' });
+      const state = merge(initialStore, {
+        messagesMap: {
+          [messageMapKey('someActiveId')]: mockMessages,
+        },
+        activeId: 'someActiveId',
+      });
       const chats = chatSelectors.currentChatsWithGuideMessage({} as MetaData)(state);
       expect(chats).toEqual(mockedChats);
     });
@@ -212,7 +238,9 @@ describe('chatSelectors', () => {
     it('should concatenate the contents of all messages returned by currentChatsWithHistoryConfig', () => {
       // Prepare a state with a few messages
       const state = merge(initialStore, {
-        messages: mockMessages,
+        messagesMap: {
+          [messageMapKey('active-session')]: mockMessages,
+        },
         activeId: 'active-session',
       });
 
@@ -241,7 +269,9 @@ describe('chatSelectors', () => {
     it('should return false if there are existing messages in the inbox session', () => {
       const state = merge(initialStore, {
         activeId: INBOX_SESSION_ID,
-        messages: mockMessages,
+        messagesMap: {
+          [messageMapKey('inbox')]: mockMessages,
+        },
       });
       const result = chatSelectors.showInboxWelcome(state);
       expect(result).toBe(false);

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

@@ -4,6 +4,7 @@ import { DEFAULT_INBOX_AVATAR, DEFAULT_USER_AVATAR } from '@/const/meta';
 import { INBOX_SESSION_ID } from '@/const/session';
 import { useAgentStore } from '@/store/agent';
 import { agentSelectors } from '@/store/agent/selectors';
+import { messageMapKey } from '@/store/chat/slices/message/utils';
 import { useSessionStore } from '@/store/session';
 import { sessionMetaSelectors } from '@/store/session/selectors';
 import { useUserStore } from '@/store/user';
@@ -33,13 +34,15 @@ const getMeta = (message: ChatMessage) => {
   }
 };
 
-const currentChatKey = (s: ChatStore) => `${s.activeId}_${s.activeTopicId}`;
+const currentChatKey = (s: ChatStore) => messageMapKey(s.activeId, s.activeTopicId);
 
 // 当前激活的消息列表
 const currentChats = (s: ChatStore): ChatMessage[] => {
   if (!s.activeId) return [];
 
-  return s.messages.map((i) => ({ ...i, meta: getMeta(i) }));
+  const messages = s.messagesMap[currentChatKey(s)] || [];
+
+  return messages.map((i) => ({ ...i, meta: getMeta(i) }));
 };
 
 const initTime = Date.now();
@@ -47,8 +50,10 @@ const initTime = Date.now();
 const showInboxWelcome = (s: ChatStore): boolean => {
   const isInbox = s.activeId === INBOX_SESSION_ID;
   if (!isInbox) return false;
+
   const data = currentChats(s);
   const isBrandNewChat = data.length === 0;
+
   return isBrandNewChat;
 };
 
@@ -107,13 +112,17 @@ const chatsMessageString = (s: ChatStore): string => {
   return chats.map((m) => m.content).join('');
 };
 
-const getMessageById = (id: string) => (s: ChatStore) => chatHelpers.getMessageById(s.messages, id);
+const getMessageById = (id: string) => (s: ChatStore) =>
+  chatHelpers.getMessageById(currentChats(s), id);
+
 const getTraceIdByMessageId = (id: string) => (s: ChatStore) => getMessageById(id)(s)?.traceId;
 
 const latestMessage = (s: ChatStore) => currentChats(s).at(-1);
 
 const currentChatLoadingState = (s: ChatStore) => !s.messagesInit;
 
+const isCurrentChatLoaded = (s: ChatStore) => !!s.messagesMap[currentChatKey(s)];
+
 const isMessageEditing = (id: string) => (s: ChatStore) => s.messageEditingIds.includes(id);
 const isMessageLoading = (id: string) => (s: ChatStore) => s.messageLoadingIds.includes(id);
 const isMessageGenerating = (id: string) => (s: ChatStore) => s.chatLoadingIds.includes(id);
@@ -137,6 +146,7 @@ export const chatSelectors = {
   getMessageById,
   getTraceIdByMessageId,
   isAIGenerating,
+  isCurrentChatLoaded,
   isMessageEditing,
   isMessageGenerating,
   isMessageLoading,

package/src/store/chat/slices/message/utils.ts

@@ -0,0 +1,7 @@
+export const messageMapKey = (sessionId: string, topicId?: string | null) => {
+  let topic = topicId;
+
+  if (typeof topicId === 'undefined') topic = null;
+
+  return `${sessionId}_${topic}`;
+};

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

@@ -7,6 +7,7 @@ import { PLUGIN_SCHEMA_API_MD5_PREFIX, PLUGIN_SCHEMA_SEPARATOR } from '@/const/p
 import { chatService } from '@/services/chat';
 import { messageService } from '@/services/message';
 import { chatSelectors } from '@/store/chat/selectors';
+import { messageMapKey } from '@/store/chat/slices/message/utils';
 import { useChatStore } from '@/store/chat/store';
 import { useToolStore } from '@/store/tool';
 import { ChatMessage, ChatToolPayload } from '@/types/message';
@@ -224,7 +225,9 @@ describe('ChatPluginAction', () => {
 
       act(() => {
         useChatStore.setState({
-          messages: [message],
+          messagesMap: {
+            [messageMapKey('session-id', 'topic-id')]: [message],
+          },
           invokeStandaloneTypePlugin: invokeStandaloneTypePluginMock,
           invokeMarkdownTypePlugin: invokeMarkdownTypePluginMock,
           invokeBuiltinTool: invokeBuiltinToolMock,
@@ -320,7 +323,9 @@ describe('ChatPluginAction', () => {
           triggerAIMessage: triggerAIMessageMock,
           internal_createMessage: internal_createMessageMock,
           activeId: 'session-id',
-          messages: [message],
+          messagesMap: {
+            [messageMapKey('session-id', 'topic-id')]: [message],
+          },
           activeTopicId: 'topic-id',
         });
       });

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 { shareService } from '@/services/share';
 import { useChatStore } from '@/store/chat';
+import { messageMapKey } from '@/store/chat/slices/message/utils';
 import { ChatMessage } from '@/types/message';
 
 describe('shareSlice actions', () => {
@@ -97,7 +98,12 @@ describe('shareSlice actions', () => {
       } as ChatMessage;
 
       act(() => {
-        useChatStore.setState({ messages: [pluginMessage] });
+        useChatStore.setState({
+          messagesMap: {
+            [messageMapKey('abc')]: [pluginMessage],
+          },
+          activeId: 'abc',
+        });
       });
 
       const { result } = renderHook(() => useChatStore());
@@ -130,7 +136,12 @@ describe('shareSlice actions', () => {
       } as ChatMessage;
 
       act(() => {
-        useChatStore.setState({ messages: [pluginMessage] });
+        useChatStore.setState({
+          messagesMap: {
+            [messageMapKey('abc')]: [pluginMessage],
+          },
+          activeId: 'abc',
+        });
       });
 
       const { result } = renderHook(() => useChatStore());
@@ -167,7 +178,12 @@ describe('shareSlice actions', () => {
       ] as ChatMessage[];
 
       act(() => {
-        useChatStore.setState({ messages });
+        useChatStore.setState({
+          messagesMap: {
+            [messageMapKey('abc')]: messages,
+          },
+          activeId: 'abc',
+        });
       });
 
       const { result } = renderHook(() => useChatStore());

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

@@ -6,6 +6,7 @@ import { LOADING_FLAT } from '@/const/message';
 import { chatService } from '@/services/chat';
 import { messageService } from '@/services/message';
 import { topicService } from '@/services/topic';
+import { messageMapKey } from '@/store/chat/slices/message/utils';
 import { ChatMessage } from '@/types/message';
 import { ChatTopic } from '@/types/topic';
 
@@ -87,7 +88,12 @@ describe('topic action', () => {
     it('should not create a topic if there are no messages', async () => {
       const { result } = renderHook(() => useChatStore());
       act(() => {
-        useChatStore.setState({ messages: [] });
+        useChatStore.setState({
+          messagesMap: {
+            [messageMapKey('session')]: [],
+          },
+          activeId: 'session',
+        });
       });
 
       const createTopicSpy = vi.spyOn(topicService, 'createTopic');
@@ -102,7 +108,12 @@ describe('topic action', () => {
       const { result } = renderHook(() => useChatStore());
       const messages = [{ id: 'message1' }, { id: 'message2' }] as ChatMessage[];
       act(() => {
-        useChatStore.setState({ messages, activeId: 'session-id' });
+        useChatStore.setState({
+          messagesMap: {
+            [messageMapKey('session-id')]: messages,
+          },
+          activeId: 'session-id',
+        });
       });
 
       const createTopicSpy = vi

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

@@ -24,7 +24,7 @@ import { chatSelectors } from '../message/selectors';
 import { ChatTopicDispatch, topicReducer } from './reducer';
 import { topicSelectors } from './selectors';
 
-const n = setNamespace('topic');
+const n = setNamespace('t');
 
 const SWR_USE_FETCH_TOPIC = 'SWR_USE_FETCH_TOPIC';
 const SWR_USE_SEARCH_TOPIC = 'SWR_USE_SEARCH_TOPIC';
@@ -38,10 +38,12 @@ export interface ChatTopicAction {
   removeTopic: (id: string) => Promise<void>;
   removeUnstarredTopic: () => void;
   saveToTopic: () => Promise<string | undefined>;
+  createTopic: () => Promise<string | undefined>;
+
   autoRenameTopicTitle: (id: string) => Promise<void>;
   duplicateTopic: (id: string) => Promise<void>;
   summaryTopicTitle: (topicId: string, messages: ChatMessage[]) => Promise<void>;
-  switchTopic: (id?: string) => Promise<void>;
+  switchTopic: (id?: string, skipRefreshMessage?: boolean) => Promise<void>;
   updateTopicTitleInSummary: (id: string, title: string) => void;
   updateTopicTitle: (id: string, title: string) => Promise<void>;
   useFetchTopics: (sessionId: string) => SWRResponse<ChatTopic[]>;
@@ -71,6 +73,21 @@ export const chatTopic: StateCreator<
     }
   },
 
+  createTopic: async () => {
+    const { activeId, internal_createTopic } = get();
+
+    const messages = chatSelectors.currentChats(get());
+    const topicId = await internal_createTopic({
+      sessionId: activeId,
+      title: t('topic.defaultTitle', { ns: 'chat' }),
+      messages: messages.map((m) => m.id),
+    });
+
+    // get().internal_updateTopicLoading(topicId, true);
+
+    return topicId;
+  },
+
   saveToTopic: async () => {
     // if there is no message, stop
     const messages = chatSelectors.currentChats(get());
@@ -189,9 +206,10 @@ export const chatTopic: StateCreator<
         },
       },
     ),
-  switchTopic: async (id) => {
-    set({ activeTopicId: id }, false, n('toggleTopic'));
+  switchTopic: async (id, skipRefreshMessage) => {
+    set({ activeTopicId: !id ? (null as any) : id }, false, n('toggleTopic'));
 
+    if (skipRefreshMessage) return;
     await get().refreshMessages();
   },
   // delete
@@ -272,7 +290,10 @@ export const chatTopic: StateCreator<
   },
   internal_createTopic: async (params) => {
     const tmpId = Date.now().toString();
-    get().internal_dispatchTopic({ type: 'addTopic', value: { ...params, id: tmpId } });
+    get().internal_dispatchTopic(
+      { type: 'addTopic', value: { ...params, id: tmpId } },
+      'internal_createTopic',
+    );
 
     get().internal_updateTopicLoading(tmpId, true);
     const topicId = await topicService.createTopic(params);
@@ -288,6 +309,6 @@ export const chatTopic: StateCreator<
   internal_dispatchTopic: (payload, action) => {
     const nextTopics = topicReducer(get().topics, payload);
 
-    set({ topics: nextTopics }, false, action);
+    set({ topics: nextTopics }, false, action ?? n(`dispatchTopic/${payload.type}`));
   },
 });