@lobehub/chat 0.107.15 → 0.107.16

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+### [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.107.16",
   "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/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;
 

package/src/store/chat/helpers.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { LobeAgentConfig } from '@/types/agent';
+import { ChatMessage } from '@/types/chatMessage';
+import { OpenAIChatMessage } from '@/types/openai/chat';
+import { encodeAsync } from '@/utils/tokenizer';
+import * as tokenizerObj from '@/utils/tokenizer';
+
+import { chatHelpers } from './helpers';
+
+// Mock encodeAsync function
+vi.mock('@/utils/tokenizer', () => ({
+  encodeAsync: vi.fn((text) => Promise.resolve(text.length)),
+}));
+
+describe('chatHelpers', () => {
+  describe('getMessagesTokenCount', () => {
+    it('returns token count for a list of messages', async () => {
+      const messages = [{ content: 'Hello' }, { content: 'World' }] as OpenAIChatMessage[];
+      const tokenCount = await chatHelpers.getMessagesTokenCount(messages);
+      expect(tokenCount).toBe('HelloWorld'.length);
+    });
+
+    it('returns 0 for an empty array', async () => {
+      const tokenCount = await chatHelpers.getMessagesTokenCount([]);
+      expect(tokenCount).toBe(0);
+    });
+
+    it('handles messages with empty content', async () => {
+      const messages = [
+        { content: 'Hello' },
+        { content: '' },
+        { content: 'World' },
+      ] as OpenAIChatMessage[];
+      const tokenCount = await chatHelpers.getMessagesTokenCount(messages);
+      expect(tokenCount).toBe('HelloWorld'.length);
+    });
+
+    it('throws an error when encodeAsync fails', async () => {
+      vi.spyOn(tokenizerObj, 'encodeAsync').mockRejectedValue(new Error('Test error'));
+      await expect(
+        chatHelpers.getMessagesTokenCount([{ content: 'Hello' }] as OpenAIChatMessage[]),
+      ).rejects.toThrow('Test error');
+    });
+  });
+
+  describe('getMessageById', () => {
+    const messages = [
+      { id: '1', content: 'Hello' },
+      { id: '2', content: 'World' },
+    ] as ChatMessage[];
+
+    it('finds a message by id', () => {
+      const message = chatHelpers.getMessageById(messages, '1');
+      expect(message).toEqual({ id: '1', content: 'Hello' });
+    });
+
+    it('returns undefined for an invalid id', () => {
+      const message = chatHelpers.getMessageById(messages, '3');
+      expect(message).toBeUndefined();
+    });
+
+    it('returns undefined for an empty array', () => {
+      const message = chatHelpers.getMessageById([], '1');
+      expect(message).toBeUndefined();
+    });
+  });
+
+  describe('getSlicedMessagesWithConfig', () => {
+    const messages = [
+      { id: '1', content: 'First' },
+      { id: '2', content: 'Second' },
+      { id: '3', content: 'Third' },
+    ] as ChatMessage[];
+
+    it('returns all messages if history is disabled', () => {
+      const config = { enableHistoryCount: false, historyCount: 0 } as LobeAgentConfig;
+      const slicedMessages = chatHelpers.getSlicedMessagesWithConfig(messages, config);
+      expect(slicedMessages).toEqual(messages);
+    });
+
+    it('returns last N messages based on historyCount', () => {
+      const config = { enableHistoryCount: true, historyCount: 2 } as LobeAgentConfig;
+      const slicedMessages = chatHelpers.getSlicedMessagesWithConfig(messages, config);
+      expect(slicedMessages).toEqual([
+        { id: '2', content: 'Second' },
+        { id: '3', content: 'Third' },
+      ]);
+    });
+
+    it('returns empty array when historyCount is negative', () => {
+      const config = { enableHistoryCount: true, historyCount: -1 } as LobeAgentConfig;
+      const slicedMessages = chatHelpers.getSlicedMessagesWithConfig(messages, config);
+      expect(slicedMessages).toEqual([]);
+    });
+
+    it('returns all messages if historyCount exceeds the array length', () => {
+      const config = { enableHistoryCount: true, historyCount: 5 } as LobeAgentConfig;
+      const slicedMessages = chatHelpers.getSlicedMessagesWithConfig(messages, config);
+      expect(slicedMessages).toEqual(messages);
+    });
+
+    it('returns an empty array for an empty message array', () => {
+      const config = { enableHistoryCount: true, historyCount: 2 } as LobeAgentConfig;
+      const slicedMessages = chatHelpers.getSlicedMessagesWithConfig([], config);
+      expect(slicedMessages).toEqual([]);
+    });
+  });
+});

package/src/store/chat/helpers.ts

@@ -6,18 +6,25 @@ import { encodeAsync } from '@/utils/tokenizer';
 export const getMessagesTokenCount = async (messages: OpenAIChatMessage[]) =>
   encodeAsync(messages.map((m) => m.content).join(''));
 
+export const getMessageById = (messages: ChatMessage[], id: string) =>
+  messages.find((m) => m.id === id);
+
 const getSlicedMessagesWithConfig = (
   messages: ChatMessage[],
   config: LobeAgentConfig,
 ): ChatMessage[] => {
-  // 如果没有开启历史消息数限制，或者限制为 0，则直接返回
+  // if historyCount is not enabled or set to 0, return all messages
   if (!config.enableHistoryCount || !config.historyCount) return messages;
 
-  // 如果开启了，则返回尾部的N条消息
-  return messages.reverse().slice(0, config.historyCount).reverse();
+  // if historyCount is negative, return empty array
+  if (config.historyCount <= 0) return [];
+
+  // if historyCount is positive, return last N messages
+  return messages.slice(-config.historyCount);
 };
 
 export const chatHelpers = {
+  getMessageById,
   getMessagesTokenCount,
   getSlicedMessagesWithConfig,
 };

package/src/store/chat/selectors/__tests__/chat.test.ts

@@ -0,0 +1,251 @@
+import { describe, expect, it } from 'vitest';
+
+import { DEFAULT_INBOX_AVATAR } from '@/const/meta';
+import { INBOX_SESSION_ID } from '@/const/session';
+import { ChatStore } from '@/store/chat';
+import { initialState } from '@/store/chat/initialState';
+import { useSessionStore } from '@/store/session';
+import { ChatMessage } from '@/types/chatMessage';
+import { MetaData } from '@/types/meta';
+import { merge } from '@/utils/merge';
+
+import { chatSelectors } from '../chat';
+
+vi.mock('i18next', () => ({
+  t: vi.fn((key) => key), // Simplified mock return value
+}));
+
+const initialStore = initialState as ChatStore;
+
+const mockMessages = [
+  {
+    id: 'msg1',
+    content: 'Hello World',
+    role: 'user',
+  },
+  {
+    id: 'msg2',
+    content: 'Goodbye World',
+    role: 'user',
+  },
+  {
+    id: 'msg3',
+    content: 'Function Message',
+    role: 'function',
+    plugin: {
+      arguments: ['arg1', 'arg2'],
+      identifier: 'func1',
+      type: 'pluginType',
+    },
+  },
+] as ChatMessage[];
+
+const mockedChats = [
+  {
+    id: 'msg1',
+    content: 'Hello World',
+    role: 'user',
+    meta: {
+      avatar: '😀',
+    },
+  },
+  {
+    id: 'msg2',
+    content: 'Goodbye World',
+    role: 'user',
+    meta: {
+      avatar: '😀',
+    },
+  },
+  {
+    id: 'msg3',
+    content: 'Function Message',
+    role: 'function',
+    meta: {
+      avatar: '🧩',
+      title: 'plugin-unknown',
+    },
+    plugin: {
+      arguments: ['arg1', 'arg2'],
+      identifier: 'func1',
+      type: 'pluginType',
+    },
+  },
+] as ChatMessage[];
+
+const mockChatStore = { messages: mockMessages } as ChatStore;
+
+describe('chatSelectors', () => {
+  describe('getMessageById', () => {
+    it('should return undefined if the message with the given id does not exist', () => {
+      const message = chatSelectors.getMessageById('non-existent-id')(initialStore);
+      expect(message).toBeUndefined();
+    });
+
+    it('should return the message object with the matching id', () => {
+      const state = merge(initialStore, { messages: mockMessages });
+      const message = chatSelectors.getMessageById('msg1')(state);
+      expect(message).toEqual(mockMessages[0]);
+    });
+
+    it('should return the message with the matching id', () => {
+      const message = chatSelectors.getMessageById('msg1')(mockChatStore);
+      expect(message).toEqual(mockMessages[0]);
+    });
+
+    it('should return undefined if no message matches the id', () => {
+      const message = chatSelectors.getMessageById('nonexistent')(mockChatStore);
+      expect(message).toBeUndefined();
+    });
+  });
+
+  describe('getFunctionMessageProps', () => {
+    it('should return the properties of a function message', () => {
+      const state = merge(initialStore, {
+        messages: mockMessages,
+        chatLoadingId: 'msg3', // Assuming this id represents a loading state
+      });
+      const props = chatSelectors.getFunctionMessageProps(mockMessages[2])(state);
+      expect(props).toEqual({
+        arguments: ['arg1', 'arg2'],
+        command: mockMessages[2].plugin,
+        content: 'Function Message',
+        id: 'func1',
+        loading: true,
+        type: 'pluginType',
+      });
+    });
+
+    it('should return loading as false if the message id is not the current loading id', () => {
+      const state = merge(initialStore, { messages: mockMessages, chatLoadingId: 'msg1' });
+      const props = chatSelectors.getFunctionMessageProps(mockMessages[2])(state);
+      expect(props.loading).toBe(false);
+    });
+
+    it('should return correct properties when no plugin is present', () => {
+      const messageWithoutPlugin = {
+        id: 'msg4',
+        content: 'No Plugin Message',
+        role: 'function',
+        // No plugin property
+      };
+      const state = merge(initialStore, {
+        messages: [...mockMessages, messageWithoutPlugin],
+        chatLoadingId: 'msg1',
+      });
+      const props = chatSelectors.getFunctionMessageProps(messageWithoutPlugin)(state);
+      expect(props).toEqual({
+        arguments: undefined,
+        command: undefined,
+        content: 'No Plugin Message',
+        id: undefined,
+        loading: false,
+        type: undefined,
+      });
+    });
+  });
+
+  describe('currentChatsWithHistoryConfig', () => {
+    it('should slice the messages according to the current agent config', () => {
+      const state = merge(initialStore, { messages: mockMessages });
+
+      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 });
+
+      useSessionStore.getState().updateAgentConfig({ historyCount: 2, enableHistoryCount: true });
+
+      const chats = chatSelectors.currentChatsWithHistoryConfig(state);
+
+      expect(chats).toHaveLength(2);
+      expect(chats).toEqual([
+        {
+          id: 'msg2',
+          content: 'Goodbye World',
+          role: 'user',
+          meta: {
+            avatar: '😀',
+          },
+        },
+        {
+          id: 'msg3',
+          content: 'Function Message',
+          role: 'function',
+          meta: {
+            avatar: '🧩',
+            title: 'plugin-unknown',
+          },
+          plugin: {
+            arguments: ['arg1', 'arg2'],
+            identifier: 'func1',
+            type: 'pluginType',
+          },
+        },
+      ]);
+    });
+  });
+
+  describe('currentChatsWithGuideMessage', () => {
+    it('should return existing messages if there are any', () => {
+      const state = merge(initialStore, { messages: mockMessages, activeId: 'someActiveId' });
+      const chats = chatSelectors.currentChatsWithGuideMessage({} as MetaData)(state);
+      expect(chats).toEqual(mockedChats);
+    });
+
+    it('should add a guide message if the chat is brand new', () => {
+      const state = merge(initialStore, { messages: [], activeId: 'someActiveId' });
+      const metaData = { title: 'Mock Agent', description: 'Mock Description' };
+
+      const chats = chatSelectors.currentChatsWithGuideMessage(metaData)(state);
+
+      expect(chats).toHaveLength(1);
+      expect(chats[0].content).toBeDefined();
+      expect(chats[0].meta.avatar).toEqual(DEFAULT_INBOX_AVATAR);
+      expect(chats[0].meta).toEqual(expect.objectContaining(metaData));
+    });
+
+    it('should use inbox message for INBOX_SESSION_ID', () => {
+      const state = merge(initialStore, { messages: [], activeId: INBOX_SESSION_ID });
+      const metaData = { title: 'Mock Agent', description: 'Mock Description' };
+
+      const chats = chatSelectors.currentChatsWithGuideMessage(metaData)(state);
+
+      expect(chats[0].content).toEqual('inbox.defaultMessage'); // Assuming translation returns a string containing this
+    });
+
+    it('should use agent default message for non-inbox sessions', () => {
+      const state = merge(initialStore, { messages: [], activeId: 'someActiveId' });
+      const metaData = { title: 'Mock Agent' };
+
+      const chats = chatSelectors.currentChatsWithGuideMessage(metaData)(state);
+
+      expect(chats[0].content).toMatch('agentDefaultMessage'); // Assuming translation returns a string containing this
+    });
+  });
+
+  describe('chatsMessageString', () => {
+    it('should concatenate the contents of all messages returned by currentChatsWithHistoryConfig', () => {
+      // Prepare a state with a few messages
+      const state = merge(initialStore, {
+        messages: mockMessages,
+        activeId: 'active-session',
+      });
+
+      // Assume that the currentChatsWithHistoryConfig will return the last two messages
+      const expectedString = mockMessages
+        .slice(-2)
+        .map((m) => m.content)
+        .join('');
+
+      // Call the selector and verify the result
+      const concatenatedString = chatSelectors.chatsMessageString(state);
+      expect(concatenatedString).toBe(expectedString);
+
+      // Restore the mocks after the test
+      vi.restoreAllMocks();
+    });
+  });
+});

package/src/store/chat/selectors/__tests__/topic.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { ChatStore, ChatStoreState } from '@/store/chat';
+import { ChatStore } from '@/store/chat';
 import { initialState } from '@/store/chat/initialState';
 import { merge } from '@/utils/merge';
 

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

@@ -3,13 +3,14 @@ import { t } from 'i18next';
 
 import { DEFAULT_INBOX_AVATAR, DEFAULT_USER_AVATAR } from '@/const/meta';
 import { INBOX_SESSION_ID } from '@/const/session';
-import { chatHelpers } from '@/store/chat/helpers';
 import { useGlobalStore } from '@/store/global';
 import { useSessionStore } from '@/store/session';
 import { agentSelectors } from '@/store/session/selectors';
 import { ChatMessage } from '@/types/chatMessage';
+import { MetaData } from '@/types/meta';
 import { merge } from '@/utils/merge';
 
+import { chatHelpers } from '../helpers';
 import type { ChatStore } from '../store';
 
 const getMeta = (message: ChatMessage) => {
@@ -47,40 +48,41 @@ const currentChats = (s: ChatStore): ChatMessage[] => {
 
 const initTime = Date.now();
 // 针对新助手添加初始化时的自定义消息
-const currentChatsWithGuideMessage = (s: ChatStore): ChatMessage[] => {
-  const data = currentChats(s);
-
-  const isBrandNewChat = data.length === 0;
-
-  if (!isBrandNewChat) return data;
-
-  const [activeId, isInbox] = [s.activeId, s.activeId === INBOX_SESSION_ID];
-  const meta = agentSelectors.currentAgentMeta(useSessionStore.getState());
-
-  const inboxMsg = t('inbox.defaultMessage', { ns: 'chat' });
-  const agentSystemRoleMsg = t('agentDefaultMessageWithSystemRole', {
-    name: meta.title || t('defaultAgent'),
-    ns: 'chat',
-    systemRole: meta.description,
-  });
-  const agentMsg = t('agentDefaultMessage', {
-    id: activeId,
-    name: meta.title || t('defaultAgent'),
-    ns: 'chat',
-  });
-
-  const emptyInboxGuideMessage = {
-    content: isInbox ? inboxMsg : !!meta.description ? agentSystemRoleMsg : agentMsg,
-    createdAt: initTime,
-    extra: {},
-    id: 'default',
-    meta: merge({ avatar: DEFAULT_INBOX_AVATAR }, meta),
-    role: 'assistant',
-    updatedAt: initTime,
-  } as ChatMessage;
-
-  return [emptyInboxGuideMessage];
-};
+const currentChatsWithGuideMessage =
+  (meta: MetaData) =>
+  (s: ChatStore): ChatMessage[] => {
+    const data = currentChats(s);
+
+    const isBrandNewChat = data.length === 0;
+
+    if (!isBrandNewChat) return data;
+
+    const [activeId, isInbox] = [s.activeId, s.activeId === INBOX_SESSION_ID];
+
+    const inboxMsg = t('inbox.defaultMessage', { ns: 'chat' });
+    const agentSystemRoleMsg = t('agentDefaultMessageWithSystemRole', {
+      name: meta.title || t('defaultAgent'),
+      ns: 'chat',
+      systemRole: meta.description,
+    });
+    const agentMsg = t('agentDefaultMessage', {
+      id: activeId,
+      name: meta.title || t('defaultAgent'),
+      ns: 'chat',
+    });
+
+    const emptyInboxGuideMessage = {
+      content: isInbox ? inboxMsg : !!meta.description ? agentSystemRoleMsg : agentMsg,
+      createdAt: initTime,
+      extra: {},
+      id: 'default',
+      meta: merge({ avatar: DEFAULT_INBOX_AVATAR }, meta),
+      role: 'assistant',
+      updatedAt: initTime,
+    } as ChatMessage;
+
+    return [emptyInboxGuideMessage];
+  };
 
 const currentChatsWithHistoryConfig = (s: ChatStore): ChatMessage[] => {
   const chats = currentChats(s);
@@ -105,9 +107,7 @@ const getFunctionMessageProps =
     type: plugin?.type as LobePluginType,
   });
 
-const getMessageById = (id: string) => (s: ChatStore) => {
-  return s.messages.find((m) => m.id === id);
-};
+const getMessageById = (id: string) => (s: ChatStore) => chatHelpers.getMessageById(s.messages, id);
 
 export const chatSelectors = {
   chatsMessageString,

package/src/store/file/slices/images/action.ts

@@ -8,7 +8,7 @@ import { setNamespace } from '@/utils/storeDebug';
 
 import { FileStore } from '../../store';
 
-const t = setNamespace('image');
+const n = setNamespace('image');
 
 export interface FileAction {
   clearImageList: () => void;
@@ -28,7 +28,7 @@ export const createFileSlice: StateCreator<
   FileAction
 > = (set, get) => ({
   clearImageList: () => {
-    set({ inputFilesList: [] }, false, t('clearImageList'));
+    set({ inputFilesList: [] }, false, n('clearImageList'));
   },
   removeAllFiles: async () => {
     await fileService.removeAllFiles();
@@ -39,7 +39,7 @@ export const createFileSlice: StateCreator<
     set(
       ({ inputFilesList }) => ({ inputFilesList: inputFilesList.filter((i) => i !== id) }),
       false,
-      t('removeFile'),
+      n('removeFile'),
     );
   },
   setImageMapItem: (id, item) => {
@@ -50,7 +50,7 @@ export const createFileSlice: StateCreator<
         draft.imagesMap[id] = item;
       }),
       false,
-      t('setImageMapItem'),
+      n('setImageMapItem'),
     );
   },
   uploadFile: async (file) => {
@@ -67,7 +67,7 @@ export const createFileSlice: StateCreator<
       set(
         ({ inputFilesList }) => ({ inputFilesList: [...inputFilesList, data.id] }),
         false,
-        t('uploadFile'),
+        n('uploadFile'),
       );
     } catch (error) {
       // 提示用户上传失败

package/src/store/global/slices/agent.ts

@@ -9,7 +9,7 @@ import { setNamespace } from '@/utils/storeDebug';
 
 import type { GlobalStore } from '../store';
 
-const t = setNamespace('settings');
+const n = setNamespace('settings');
 
 /**
  * 设置操作
@@ -29,6 +29,6 @@ export const createAgentSlice: StateCreator<
       draft.defaultAgent = merge(draft.defaultAgent, agent);
     });
 
-    set({ settings }, false, t('updateDefaultAgent', agent));
+    set({ settings }, false, n('updateDefaultAgent', agent));
   },
 });

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

@@ -11,7 +11,7 @@ import { setNamespace } from '@/utils/storeDebug';
 import type { GlobalPreference, GlobalState, Guide, SidebarTabKey } from '../initialState';
 import type { GlobalStore } from '../store';
 
-const t = setNamespace('settings');
+const n = setNamespace('settings');
 
 /**
  * 设置操作
@@ -37,25 +37,25 @@ export const createCommonSlice: StateCreator<
   CommonAction
 > = (set, get) => ({
   switchSideBar: (key) => {
-    set({ sidebarKey: key }, false, t('switchSideBar', key));
+    set({ sidebarKey: key }, false, n('switchSideBar', key));
   },
   toggleChatSideBar: (newValue) => {
     const showChatSideBar =
       typeof newValue === 'boolean' ? newValue : !get().preference.showChatSideBar;
 
-    get().updatePreference({ showChatSideBar }, t('toggleAgentPanel', newValue) as string);
+    get().updatePreference({ showChatSideBar }, n('toggleAgentPanel', newValue) as string);
   },
   toggleMobileTopic: (newValue) => {
     const mobileShowTopic =
       typeof newValue === 'boolean' ? newValue : !get().preference.mobileShowTopic;
 
-    get().updatePreference({ mobileShowTopic }, t('toggleMobileTopic', newValue) as string);
+    get().updatePreference({ mobileShowTopic }, n('toggleMobileTopic', newValue) as string);
   },
   toggleSystemRole: (newValue) => {
     const showSystemRole =
       typeof newValue === 'boolean' ? newValue : !get().preference.mobileShowTopic;
 
-    get().updatePreference({ showSystemRole }, t('toggleMobileTopic', newValue) as string);
+    get().updatePreference({ showSystemRole }, n('toggleMobileTopic', newValue) as string);
   },
   updateGuideState: (guide) => {
     const { updatePreference } = get();
@@ -75,7 +75,7 @@ export const createCommonSlice: StateCreator<
     useSWR('checkLatestVersion', featLatestVersion, {
       onSuccess: (data: string) => {
         if (gt(data, CURRENT_VERSION))
-          set({ hasNewVersion: true, latestVersion: data }, false, t('checkLatestVersion'));
+          set({ hasNewVersion: true, latestVersion: data }, false, n('checkLatestVersion'));
       },
     }),
 });

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

@@ -12,7 +12,7 @@ import { setNamespace } from '@/utils/storeDebug';
 
 import type { GlobalStore } from '../store';
 
-const t = setNamespace('settings');
+const n = setNamespace('settings');
 
 /**
  * 设置操作
@@ -58,10 +58,10 @@ export const createSettingsSlice: StateCreator<
     const settings = produce(get().settings, (draft: GlobalSettings) => {
       draft.defaultAgent = DEFAULT_AGENT;
     });
-    set({ settings }, false, t('resetDefaultAgent'));
+    set({ settings }, false, n('resetDefaultAgent'));
   },
   resetSettings: () => {
-    set({ settings: DEFAULT_SETTINGS }, false, t('resetSettings'));
+    set({ settings: DEFAULT_SETTINGS }, false, n('resetSettings'));
   },
   setOpenAIConfig: (config) => {
     get().setSettings({ languageModel: { openAI: config } });
@@ -73,7 +73,7 @@ export const createSettingsSlice: StateCreator<
 
     if (isEqual(prevSetting, nextSettings)) return;
 
-    set({ settings: merge(prevSetting, settings) }, false, t('setSettings', settings));
+    set({ settings: merge(prevSetting, settings) }, false, n('setSettings', settings));
   },
   switchSettingTabs: (tab) => {
     set({ settingsTab: tab });

package/src/store/plugin/slices/customPlugin/action.ts

@@ -8,7 +8,7 @@ import { PluginStore } from '../../store';
 import { defaultCustomPlugin } from './initialState';
 import { CustomPluginListDispatch, devPluginListReducer } from './reducers/customPluginList';
 
-const t = setNamespace('customPlugin');
+const n = setNamespace('customPlugin');
 
 /**
  * 代理行为接口
@@ -40,11 +40,11 @@ export const createCustomPluginSlice: StateCreator<
     const { customPluginList } = get();
 
     const nextList = devPluginListReducer(customPluginList, payload);
-    set({ customPluginList: nextList }, false, t('dispatchCustomPluginList', payload));
+    set({ customPluginList: nextList }, false, n('dispatchCustomPluginList', payload));
   },
   saveToCustomPluginList: (value) => {
     get().dispatchCustomPluginList({ plugin: value, type: 'addItem' });
-    set({ newCustomPlugin: defaultCustomPlugin }, false, t('saveToCustomPluginList'));
+    set({ newCustomPlugin: defaultCustomPlugin }, false, n('saveToCustomPluginList'));
   },
   updateCustomPlugin: (id, value) => {
     const { dispatchCustomPluginList, installPlugin } = get();
@@ -58,7 +58,7 @@ export const createCustomPluginSlice: StateCreator<
     set(
       { newCustomPlugin: merge({}, get().newCustomPlugin, newCustomPlugin) },
       false,
-      t('updateNewDevPlugin'),
+      n('updateNewDevPlugin'),
     );
   },
 });

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

@@ -17,7 +17,7 @@ import { setNamespace } from '@/utils/storeDebug';
 import { PluginStore } from '../../store';
 import { PluginDispatch, pluginManifestReducer } from './reducers/manifest';
 
-const t = setNamespace('plugin');
+const n = setNamespace('plugin');
 
 /**
  * 插件接口
@@ -73,7 +73,7 @@ export const createPluginSlice: StateCreator<
 
     await installPlugins(plugins);
 
-    set({ manifestPrepared: true }, false, t('checkPluginsIsInstalled'));
+    set({ manifestPrepared: true }, false, n('checkPluginsIsInstalled'));
   },
   deletePluginSettings: (id) => {
     set(
@@ -81,14 +81,14 @@ export const createPluginSlice: StateCreator<
         draft.pluginsSettings[id] = undefined;
       }),
       false,
-      t('deletePluginSettings'),
+      n('deletePluginSettings'),
     );
   },
   dispatchPluginManifest: (payload) => {
     const { pluginManifestMap } = get();
     const nextManifest = pluginManifestReducer(pluginManifestMap, payload);
 
-    set({ pluginManifestMap: nextManifest }, false, t('dispatchPluginManifest', payload));
+    set({ pluginManifestMap: nextManifest }, false, n('dispatchPluginManifest', payload));
   },
   installPlugin: async (name) => {
     const plugin = pluginSelectors.getPluginMetaById(name)(get());
@@ -140,12 +140,12 @@ export const createPluginSlice: StateCreator<
   loadPluginStore: async () => {
     const pluginMarketIndex = await pluginService.getPluginList();
 
-    set({ pluginList: pluginMarketIndex.plugins }, false, t('loadPluginList'));
+    set({ pluginList: pluginMarketIndex.plugins }, false, n('loadPluginList'));
 
     return pluginMarketIndex;
   },
   resetPluginSettings: () => {
-    set({ pluginsSettings: {} }, false, t('resetPluginSettings'));
+    set({ pluginsSettings: {} }, false, n('resetPluginSettings'));
   },
   updateManifestLoadingState: (key, value) => {
     set(
@@ -153,7 +153,7 @@ export const createPluginSlice: StateCreator<
         draft.pluginManifestLoading[key] = value;
       }),
       false,
-      t('updateManifestLoadingState'),
+      n('updateManifestLoadingState'),
     );
   },
   updatePluginSettings: (id, settings) => {
@@ -162,7 +162,7 @@ export const createPluginSlice: StateCreator<
         draft.pluginsSettings[id] = merge({}, draft.pluginsSettings[id], settings);
       }),
       false,
-      t('updatePluginSettings'),
+      n('updatePluginSettings'),
     );
   },
 

package/src/store/session/slices/session/action.ts

@@ -18,7 +18,7 @@ import { setNamespace } from '@/utils/storeDebug';
 
 import { initLobeSession } from './initialState';
 
-const t = setNamespace('session');
+const n = setNamespace('session');
 
 const FETCH_SESSIONS_KEY = 'fetchSessions';
 
@@ -80,7 +80,7 @@ export const createSessionSlice: StateCreator<
   SessionAction
 > = (set, get) => ({
   activeSession: (sessionId) => {
-    set({ activeId: sessionId }, false, t('activeSession'));
+    set({ activeId: sessionId }, false, n('activeSession'));
   },
 
   clearSessions: async () => {
@@ -153,7 +153,7 @@ export const createSessionSlice: StateCreator<
             sessions: data,
           },
           false,
-          t('useFetchSessions/onSuccess', data),
+          n('useFetchSessions/onSuccess', data),
         );
       },
     }),
@@ -161,7 +161,7 @@ export const createSessionSlice: StateCreator<
   useSearchSessions: (keyword) =>
     useSWR<LobeSessions>(keyword, sessionService.searchSessions, {
       onSuccess: (data) => {
-        set({ searchSessions: data }, false, t('useSearchSessions(success)', data));
+        set({ searchSessions: data }, false, n('useSearchSessions(success)', data));
       },
       revalidateOnFocus: false,
     }),