@lobehub/chat 0.18.2 → 0.20.0

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

@@ -1,12 +1,9 @@
 export interface ChatState {
+  activeTopicId?: string;
   chatLoading: boolean;
-  editingMessageId?: string;
+  topicLoadingId?: string;
 }
 
 export const initialChatState: ChatState = {
   chatLoading: false,
-
-  // activeId: null,
-  // searchKeywords: '',
-  //
 };

package/src/store/session/slices/chat/{messageReducer.test.ts → reducers/message.test.ts}

@@ -1,6 +1,6 @@
 import { ChatMessageMap } from '@/types/chatMessage';
 
-import { MessageDispatch, messagesReducer } from './messageReducer';
+import { MessageDispatch, messagesReducer } from './message';
 
 describe('messagesReducer', () => {
   let initialState: ChatMessageMap;
@@ -116,6 +116,30 @@ describe('messagesReducer', () => {
         quotaId: 'message2',
       });
     });
+
+    it('should use the provided parentId and quotaId when adding a new message', () => {
+      const payload: MessageDispatch = {
+        type: 'addMessage',
+        message: 'New Message',
+        id: 'message3',
+        role: 'user',
+        parentId: 'message1',
+        quotaId: 'message2',
+      };
+
+      const newState = messagesReducer(initialState, payload);
+
+      expect(newState.message3).toEqual({
+        id: 'message3',
+        content: 'New Message',
+        meta: {},
+        createAt: expect.any(Number),
+        updateAt: expect.any(Number),
+        role: 'user',
+        parentId: 'message1',
+        quotaId: 'message2',
+      });
+    });
   });
 
   describe('deleteMessage', () => {
@@ -142,6 +166,17 @@ describe('messagesReducer', () => {
 
       expect(newState).toEqual(initialState);
     });
+
+    it('should not modify the state if the specified message does not exist', () => {
+      const payload: MessageDispatch = {
+        type: 'deleteMessage',
+        id: 'nonexistentMessage',
+      };
+
+      const newState = messagesReducer(initialState, payload);
+
+      expect(newState).toEqual(initialState);
+    });
   });
 
   describe('updateMessage', () => {
@@ -171,6 +206,19 @@ describe('messagesReducer', () => {
 
       expect(newState).toEqual(initialState);
     });
+
+    it('should not modify the state if the specified message does not exist', () => {
+      const payload: MessageDispatch = {
+        type: 'updateMessage',
+        id: 'nonexistentMessage',
+        key: 'content',
+        value: 'Updated Message',
+      };
+
+      const newState = messagesReducer(initialState, payload);
+
+      expect(newState).toEqual(initialState);
+    });
   });
 
   describe('updateMessageExtra', () => {
@@ -200,6 +248,19 @@ describe('messagesReducer', () => {
 
       expect(newState).toEqual(initialState);
     });
+
+    it('should not modify the state if the specified message does not exist', () => {
+      const payload: MessageDispatch = {
+        type: 'updateMessageExtra',
+        id: 'nonexistentMessage',
+        key: 'translate',
+        value: { target: 'en', to: 'zh' },
+      };
+
+      const newState = messagesReducer(initialState, payload);
+
+      expect(newState).toEqual(initialState);
+    });
   });
 
   describe('resetMessages', () => {
@@ -212,6 +273,37 @@ describe('messagesReducer', () => {
 
       expect(newState).toEqual({});
     });
+
+    it('should delete messages with the specified topicId', () => {
+      const initialState = {
+        message1: {
+          id: 'message1',
+          content: 'Hello World',
+          createAt: 1629264000000,
+          updateAt: 1629264000000,
+          role: 'user',
+          topicId: 'topic1',
+        },
+        message2: {
+          id: 'message2',
+          content: 'How are you?',
+          createAt: 1629264000000,
+          updateAt: 1629264000000,
+          role: 'system',
+        },
+      } as unknown as ChatMessageMap;
+
+      const payload: MessageDispatch = {
+        type: 'resetMessages',
+        topicId: 'topic1',
+      };
+
+      const newState = messagesReducer(initialState, payload);
+
+      expect(Object.keys(newState)).toHaveLength(1);
+      expect(newState).not.toHaveProperty('message1');
+      expect(newState).toHaveProperty('message2');
+    });
   });
 
   describe('unimplemented type', () => {

package/src/store/session/slices/chat/{messageReducer.ts → reducers/message.ts}

@@ -21,6 +21,7 @@ interface DeleteMessage {
 }
 
 interface ResetMessages {
+  topicId?: string;
   type: 'resetMessages';
 }
 
@@ -101,7 +102,21 @@ export const messagesReducer = (
     }
 
     case 'resetMessages': {
-      return {};
+      return produce(state, (draftState) => {
+        const { topicId } = payload;
+
+        const messages = Object.values(draftState).filter((message) => {
+          // 如果没有 topicId，说明是清空默认对话里的消息
+          if (!topicId) return !message.topicId;
+
+          return message.topicId === topicId;
+        });
+
+        // 删除上述找到的消息
+        for (const message of messages) {
+          delete draftState[message.id];
+        }
+      });
     }
 
     default: {

package/src/store/session/slices/chat/reducers/topic.test.ts

@@ -0,0 +1,179 @@
+import { produce } from 'immer';
+
+import { ChatTopic, ChatTopicMap } from '@/types/topic';
+
+import { ChatTopicDispatch, topicReducer } from './topic';
+
+describe('topicReducer', () => {
+  let state: ChatTopicMap;
+
+  beforeEach(() => {
+    state = {};
+  });
+
+  describe('addChatTopic', () => {
+    it('should add a new ChatTopic object to state', () => {
+      const payload: ChatTopicDispatch = {
+        type: 'addChatTopic',
+        topic: {
+          id: '1',
+          title: 'Test Topic',
+          createAt: Date.now(),
+          updateAt: Date.now(),
+        },
+      };
+
+      const newState = topicReducer(state, payload);
+
+      expect(newState).toMatchObject({
+        '1': payload.topic,
+      });
+    });
+
+    it('should add a ChatTopic object with correct id', () => {
+      const payload: ChatTopicDispatch = {
+        type: 'addChatTopic',
+        topic: {
+          id: '1',
+          title: 'Test Topic',
+          createAt: Date.now(),
+          updateAt: Date.now(),
+        },
+      };
+
+      const newState = topicReducer(state, payload);
+
+      expect(newState['1']).toBeDefined();
+    });
+
+    it('should add a ChatTopic object with correct properties', () => {
+      const payload: ChatTopicDispatch = {
+        type: 'addChatTopic',
+        topic: {
+          id: '1',
+          title: 'Test Topic',
+          createAt: Date.now(),
+          updateAt: Date.now(),
+        },
+      };
+
+      const newState = topicReducer(state, payload);
+
+      expect(newState['1']).toMatchObject(payload.topic);
+    });
+  });
+
+  describe('updateChatTopic', () => {
+    it('should update the ChatTopic object in state', () => {
+      const topic: ChatTopic = {
+        id: '1',
+        title: 'Test Topic',
+        createAt: Date.now(),
+        updateAt: Date.now(),
+      };
+
+      state['1'] = topic;
+
+      const payload: ChatTopicDispatch = {
+        type: 'updateChatTopic',
+        id: '1',
+        key: 'title',
+        value: 'Updated Topic',
+      };
+
+      const newState = topicReducer(state, payload);
+
+      expect(newState['1'].title).toBe('Updated Topic');
+    });
+
+    it('should update the ChatTopic object with correct properties', () => {
+      const topic: ChatTopic = {
+        id: '1',
+        title: 'Test Topic',
+        createAt: Date.now() - 1,
+        updateAt: Date.now() - 1, // 设定比当前时间前面一点
+      };
+
+      state['1'] = topic;
+
+      const payload: ChatTopicDispatch = {
+        type: 'updateChatTopic',
+        id: '1',
+        key: 'title',
+        value: 'Updated Topic',
+      };
+
+      const newState = topicReducer(state, payload);
+
+      expect(newState['1'].updateAt).toBeGreaterThan(topic.updateAt);
+    });
+  });
+
+  describe('deleteChatTopic', () => {
+    it('should delete the specified ChatTopic object from state', () => {
+      const topic: ChatTopic = {
+        id: '1',
+        title: 'Test Topic',
+        createAt: Date.now(),
+        updateAt: Date.now(),
+      };
+
+      state['1'] = topic;
+
+      const payload: ChatTopicDispatch = {
+        type: 'deleteChatTopic',
+        id: '1',
+      };
+
+      const newState = topicReducer(state, payload);
+
+      expect(newState['1']).toBeUndefined();
+    });
+  });
+
+  describe('default', () => {
+    it('should return the original state object', () => {
+      const payload = {
+        type: 'unknown',
+      } as unknown as ChatTopicDispatch;
+
+      const newState = topicReducer(state, payload);
+
+      expect(newState).toBe(state);
+    });
+  });
+
+  describe('produce', () => {
+    it('should generate immutable state object', () => {
+      const payload: ChatTopicDispatch = {
+        type: 'addChatTopic',
+        topic: {
+          id: '1',
+          title: 'Test Topic',
+          createAt: Date.now(),
+          updateAt: Date.now(),
+        },
+      };
+
+      const newState = topicReducer(state, payload);
+
+      expect(newState).not.toBe(state);
+    });
+
+    it('should not modify the original state object', () => {
+      const payload: ChatTopicDispatch = {
+        type: 'addChatTopic',
+        topic: {
+          id: '1',
+          title: 'Test Topic',
+          createAt: Date.now(),
+          updateAt: Date.now(),
+        },
+      };
+
+      const newState = topicReducer(state, payload);
+
+      expect(state).toMatchObject({});
+    });
+  });
+});

package/src/store/session/slices/chat/reducers/topic.ts

@@ -0,0 +1,59 @@
+import { produce } from 'immer';
+
+import { ChatTopic, ChatTopicMap } from '@/types/topic';
+
+interface AddChatTopicAction {
+  topic: ChatTopic;
+  type: 'addChatTopic';
+}
+
+interface UpdateChatTopicAction {
+  id: string;
+  key: keyof ChatTopic;
+  type: 'updateChatTopic';
+  value: any;
+}
+
+interface DeleteChatTopicAction {
+  id: string;
+  type: 'deleteChatTopic';
+}
+
+export type ChatTopicDispatch = AddChatTopicAction | UpdateChatTopicAction | DeleteChatTopicAction;
+
+export const topicReducer = (state: ChatTopicMap, payload: ChatTopicDispatch): ChatTopicMap => {
+  switch (payload.type) {
+    case 'addChatTopic': {
+      return produce(state, (draftState) => {
+        draftState[payload.topic.id] = payload.topic;
+      });
+    }
+
+    case 'updateChatTopic': {
+      return produce(state, (draftState) => {
+        const { key, value, id } = payload;
+
+        if (!draftState[id]) return;
+
+        const topic = draftState[id];
+
+        if (value !== undefined) {
+          // @ts-ignore
+          topic[key] = value;
+
+          topic.updateAt = Date.now();
+        }
+      });
+    }
+
+    case 'deleteChatTopic': {
+      return produce(state, (draftState) => {
+        delete draftState[payload.id];
+      });
+    }
+
+    default: {
+      return state;
+    }
+  }
+};

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

@@ -12,10 +12,14 @@ export const currentChats = (s: SessionStore): ChatMessage[] => {
   const session = sessionSelectors.currentSession(s);
   if (!session) return [];
 
-  return organizeChats(session, {
-    assistant: agentSelectors.currentAgentAvatar(s),
-    user: useSettings.getState().settings.avatar || DEFAULT_USER_AVATAR,
-  });
+  return organizeChats(
+    session,
+    {
+      assistant: agentSelectors.currentAgentAvatar(s),
+      user: useSettings.getState().settings.avatar || DEFAULT_USER_AVATAR,
+    },
+    s.activeTopicId,
+  );
 };
 
 export const systemRoleSel = (s: SessionStore): string => {

package/src/store/session/slices/chat/selectors/index.ts

@@ -1,5 +1,6 @@
 import { currentChats } from './chat';
 import { chatsTokenCount, systemRoleTokenCount, totalTokenCount } from './token';
+import { currentTopics } from './topic';
 
 export const chatSelectors = {
   chatsTokenCount,
@@ -7,3 +8,7 @@ export const chatSelectors = {
   systemRoleTokenCount,
   totalTokenCount,
 };
+
+export const topicSelectors = {
+  currentTopics,
+};

package/src/store/session/slices/chat/selectors/topic.ts

@@ -0,0 +1,16 @@
+// 展示在聊天框中的消息
+import { SessionStore, sessionSelectors } from '@/store/session';
+import { ChatTopic } from '@/types/topic';
+
+export const currentTopics = (s: SessionStore): ChatTopic[] => {
+  const session = sessionSelectors.currentSession(s);
+  if (!session) return [];
+
+  const topics = Object.values(session.topics || {});
+
+  // 按时间倒序
+  const favTopics = topics.filter((t) => t.favorite).sort((a, b) => b.updateAt - a.updateAt);
+  const defaultTopics = topics.filter((t) => !t.favorite).sort((a, b) => b.updateAt - a.updateAt);
+
+  return [...favTopics, ...defaultTopics];
+};

package/src/store/session/slices/chat/selectors/utils.test.ts

@@ -1,5 +1,6 @@
-import { beforeEach } from 'vitest';
+import { beforeEach, describe } from 'vitest';
 
+import { ChatMessage } from '@/types/chatMessage';
 import { LobeAgentSession } from '@/types/session';
 
 import { organizeChats } from './utils';
@@ -67,7 +68,7 @@ describe('organizeChats', () => {
   });
 
   it('should filter out archived messages', () => {
-    session.chats['2'].archive = true;
+    session.chats['2'].topicId = '123';
     const result = organizeChats(session, { assistant: '', user: '' });
     expect(result.length).toBe(2);
     expect(result[0].id).toBe('1');
@@ -261,4 +262,83 @@ describe('organizeChats', () => {
       },
     ]);
   });
+
+  const avatar = {
+    assistant: 'assistant-avatar',
+    user: 'user-avatar',
+  };
+
+  it('should organize chats in chronological order when topicId is not provided', () => {
+    const result = organizeChats(session, avatar);
+
+    expect(result.length).toBe(3);
+    expect(result[0].id).toBe('1');
+    expect(result[1].id).toBe('2');
+    expect(result[2].id).toBe('3');
+  });
+
+  it('should only return chats with specified topicId when topicId is provided', () => {
+    const result = organizeChats(session, avatar, 'topic-id');
+
+    expect(result.length).toBe(0);
+  });
+
+  describe('user Meta', () => {
+    it('should return correct meta for user role', () => {
+      const result = organizeChats(session, avatar);
+      const meta = result[1].meta;
+
+      expect(meta.avatar).toBe(avatar.user);
+    });
+
+    it('should return correct meta for assistant role', () => {
+      const result = organizeChats(session, avatar);
+      const meta = result[0].meta;
+
+      expect(meta.avatar).toBe(avatar.assistant);
+      expect(meta.title).toBeUndefined();
+    });
+
+    describe('should return correct meta for function role', () => {
+      it('找不到插件', () => {
+        const message = {
+          id: '4',
+          createAt: 1927785600004,
+          updateAt: 1927785600004,
+          role: 'function',
+          function_call: {
+            name: 'plugin-name',
+          },
+        } as ChatMessage;
+
+        session.chats[message.id] = message;
+
+        const result = organizeChats(session, avatar);
+        const meta = result[3].meta;
+
+        expect(meta.avatar).toBe('🧩');
+        expect(meta.title).toBe('plugin-unknown');
+      });
+
+      it('找到的插件', () => {
+        const message = {
+          id: '4',
+          createAt: 1927785600004,
+          updateAt: 1927785600004,
+          role: 'function',
+          function_call: {
+            name: 'realtimeWeather',
+          },
+        } as ChatMessage;
+
+        session.chats[message.id] = message;
+
+        const result = organizeChats(session, avatar);
+        const meta = result[3].meta;
+
+        expect(meta.avatar).toBe('☂️');
+        expect(meta.title).toBe('realtimeWeather');
+      });
+    });
+  });
 });

package/src/store/session/slices/chat/selectors/utils.ts

@@ -5,6 +5,7 @@ import { LobeAgentSession } from '@/types/session';
 export const organizeChats = (
   session: LobeAgentSession,
   avatar: { assistant: string; user: string },
+  topicId?: string,
 ) => {
   const getMeta = (message: ChatMessage) => {
     switch (message.role) {
@@ -38,8 +39,13 @@ export const organizeChats = (
   const basic = Object.values<ChatMessage>(session.chats)
     // 首先按照时间顺序排序，越早的在越前面
     .sort((pre, next) => pre.createAt - next.createAt)
-    // 过滤掉已归档的消息，归档消息不应该出现在聊天框中
-    .filter((m) => !m.archive)
+    .filter((m) => {
+      // 过滤掉包含 topicId 的消息，有主题的消息不应该出现在聊天框中
+      if (!topicId) return !m.topicId;
+
+      // 或者当话题 id 一致时，再展示话题
+      return m.topicId === topicId;
+    })
     // 映射头像关系
     .map((m) => {
       return {

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

@@ -3,6 +3,7 @@ import { produce } from 'immer';
 import { ChatMessageMap } from '@/types/chatMessage';
 import { MetaData } from '@/types/meta';
 import { LobeAgentConfig, LobeAgentSession, LobeSessions } from '@/types/session';
+import { ChatTopicMap } from '@/types/topic';
 
 /**
  * @title 添加会话
@@ -37,6 +38,19 @@ interface UpdateSessionChat {
   type: 'updateSessionChat';
 }
 
+/**
+ * @title 更新会话聊天上下文
+ */
+interface UpdateSessionTopic {
+  /**
+   * 会话 ID
+   */
+  id: string;
+  topics: ChatTopicMap;
+
+  type: 'updateSessionTopic';
+}
+
 interface UpdateSessionMeta {
   id: string;
   key: keyof MetaData;
@@ -55,7 +69,8 @@ export type SessionDispatch =
   | UpdateSessionChat
   | RemoveSession
   | UpdateSessionMeta
-  | UpdateSessionAgentConfig;
+  | UpdateSessionAgentConfig
+  | UpdateSessionTopic;
 
 export const sessionsReducer = (state: LobeSessions, payload: SessionDispatch): LobeSessions => {
   switch (payload.type) {
@@ -96,6 +111,15 @@ export const sessionsReducer = (state: LobeSessions, payload: SessionDispatch):
       });
     }
 
+    case 'updateSessionTopic': {
+      return produce(state, (draft) => {
+        const chat = draft[payload.id];
+        if (!chat) return;
+
+        chat.topics = payload.topics;
+      });
+    }
+
     case 'updateSessionConfig': {
       return produce(state, (draft) => {
         const { id, config } = payload;

package/src/types/chatMessage.ts

@@ -14,8 +14,6 @@ export interface ChatMessageError {
 }
 
 export interface ChatMessage extends BaseDataModel {
-  archive?: boolean;
-
   /**
    * @title 内容
    * @description 消息内容
@@ -43,6 +41,10 @@ export interface ChatMessage extends BaseDataModel {
    * @description 消息发送者的角色
    */
   role: LLMRoleType;
+  /**
+   * 保存到主题的消息
+   */
+  topicId?: string;
 }
 
 export type ChatMessageMap = Record<string, ChatMessage>;

package/src/types/session.ts

@@ -1,6 +1,7 @@
 import { ChatMessageMap } from './chatMessage';
 import { LLMExample, LLMParams, LanguageModel } from './llm';
 import { BaseDataModel } from './meta';
+import { ChatTopicMap } from './topic';
 
 export enum LobeSessionType {
   /**
@@ -18,7 +19,7 @@ interface LobeSessionBase extends BaseDataModel {
    * 聊天记录
    */
   chats: ChatMessageMap;
-
+  topics?: ChatTopicMap;
   /**
    * 每个会话的类别
    */

package/src/types/topic.ts

@@ -0,0 +1,8 @@
+import { BaseDataModel } from '@/types/meta';
+
+export interface ChatTopic extends Omit<BaseDataModel, 'meta'> {
+  favorite?: boolean;
+  title: string;
+}
+
+export type ChatTopicMap = Record<string, ChatTopic>;