@lobehub/chat 1.0.0

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

@@ -0,0 +1,456 @@
+import { produce } from 'immer';
+
+import { ChatMessage } from '@/types/chatMessage';
+import { LanguageModel } from '@/types/llm';
+import { MetaData } from '@/types/meta';
+import { LobeAgentConfig, LobeAgentSession, LobeSessionType, LobeSessions } from '@/types/session';
+
+import { SessionDispatch, sessionsReducer } from './session';
+
+describe('sessionsReducer', () => {
+  describe('addSession', () => {
+    it('should add session to state when valid session and type are provided', () => {
+      const state: LobeSessions = {};
+      const session = {
+        id: 'session-id',
+        config: {
+          model: LanguageModel.GPT3_5,
+          params: {},
+          systemRole: 'system-role',
+        },
+        type: LobeSessionType.Agent,
+      } as LobeAgentSession;
+      const payload: SessionDispatch = {
+        type: 'addSession',
+        session,
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual({
+        'session-id': session,
+      });
+    });
+
+    it('should not change state when invalid session and type are provided', () => {
+      const state: LobeSessions = {};
+      const session = undefined as unknown as LobeAgentSession;
+      const payload: SessionDispatch = {
+        type: 'addSession',
+        session,
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual(state);
+    });
+  });
+
+  describe('removeSession', () => {
+    it('should remove session from state when valid id and type are provided', () => {
+      const state = {
+        'session-id': {
+          id: 'session-id',
+          config: {
+            model: 'gpt-3.5-turbo',
+            params: {},
+            systemRole: 'system-role',
+          },
+          type: 'agent',
+        } as LobeAgentSession,
+      } as LobeSessions;
+      const id = 'session-id';
+      const payload: SessionDispatch = {
+        type: 'removeSession',
+        id,
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual({});
+    });
+
+    it('should not change state when invalid id and type are provided', () => {
+      const state: LobeSessions = {
+        'session-id': {
+          id: 'session-id',
+          config: {
+            model: 'gpt-3.5-turbo',
+            params: {},
+            systemRole: 'system-role',
+          },
+          type: 'agent',
+        } as LobeAgentSession,
+      };
+      const id = 'non-existent-id';
+      const payload: SessionDispatch = {
+        type: 'removeSession',
+        id,
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual(state);
+    });
+  });
+
+  describe('updateSessionMeta', () => {
+    it('should update session meta when valid id, key, and value are provided', () => {
+      const state: LobeSessions = {
+        'session-id': {
+          id: 'session-id',
+          config: {
+            model: 'gpt-3.5-turbo',
+            params: {},
+            systemRole: 'system-role',
+          },
+          type: 'agent',
+          meta: {
+            avatar: 'avatar-url',
+            backgroundColor: 'background-color',
+            description: 'description',
+            tag: ['tag1', 'tag2'],
+            title: 'title',
+          },
+        } as LobeAgentSession,
+      };
+      const id = 'session-id';
+      const key: keyof MetaData = 'title';
+      const value = 'new-title';
+      const payload: SessionDispatch = {
+        type: 'updateSessionMeta',
+        id,
+        key,
+        value,
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual({
+        'session-id': {
+          ...state['session-id'],
+          meta: {
+            ...state['session-id'].meta,
+            title: 'new-title',
+          },
+        },
+      });
+    });
+
+    it('should not change state when invalid id, key, and value are provided', () => {
+      const state: LobeSessions = {
+        'session-id': {
+          id: 'session-id',
+          config: {
+            model: 'gpt-3.5-turbo',
+            params: {},
+            systemRole: 'system-role',
+          },
+          type: 'agent',
+          meta: {
+            avatar: 'avatar-url',
+            backgroundColor: 'background-color',
+            description: 'description',
+            tag: ['tag1', 'tag2'],
+            title: 'title',
+          },
+        } as LobeAgentSession,
+      };
+      const id = 'non-existent-id';
+      const key = 'invalid-key' as keyof MetaData;
+      const value = 'new-value';
+      const payload: SessionDispatch = {
+        type: 'updateSessionMeta',
+        id,
+        key,
+        value,
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual(state);
+    });
+
+    it('should not change state when valid id, invalid key, and value are provided', () => {
+      const state: LobeSessions = {
+        'session-id': {
+          id: 'session-id',
+          config: {
+            model: 'gpt-3.5-turbo',
+            params: {},
+            systemRole: 'system-role',
+          },
+          type: 'agent',
+          meta: {
+            avatar: 'avatar-url',
+            backgroundColor: 'background-color',
+            description: 'description',
+            tag: ['tag1', 'tag2'],
+            title: 'title',
+          },
+        } as LobeAgentSession,
+      };
+      const id = 'session-id';
+      const key = 'invalid-key' as keyof MetaData;
+      const value = 'new-value';
+      const payload: SessionDispatch = {
+        type: 'updateSessionMeta',
+        id,
+        key,
+        value,
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual(state);
+    });
+  });
+
+  describe('updateSessionConfig', () => {
+    it('should update session config when valid id and partial config are provided', () => {
+      const state: LobeSessions = {
+        'session-id': {
+          id: 'session-id',
+          config: {
+            model: 'gpt-3.5-turbo',
+            params: {},
+            systemRole: 'system-role',
+          },
+          type: 'agent',
+          meta: {
+            avatar: 'avatar-url',
+            backgroundColor: 'background-color',
+            description: 'description',
+            tag: ['tag1', 'tag2'],
+            title: 'title',
+          },
+        } as LobeAgentSession,
+      };
+      const id = 'session-id';
+      const config: Partial<LobeAgentConfig> = {
+        model: LanguageModel.GPT4,
+      };
+      const payload: SessionDispatch = {
+        type: 'updateSessionConfig',
+        id,
+        config,
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual({
+        'session-id': {
+          ...state['session-id'],
+          config: {
+            ...state['session-id'].config,
+            model: 'gpt-4',
+          },
+        },
+      });
+    });
+
+    it('should update session agent config correctly', () => {
+      const state: LobeSessions = {
+        session1: {
+          id: 'session1',
+          config: {
+            model: 'gpt-3.5-turbo',
+            params: {},
+            systemRole: 'system',
+          },
+        } as LobeAgentSession,
+        session2: {
+          id: 'session2',
+          config: {
+            model: 'gpt-3.5-turbo',
+            params: {},
+            systemRole: 'system',
+          },
+        } as LobeAgentSession,
+      };
+
+      const payload: SessionDispatch = {
+        type: 'updateSessionConfig',
+        id: 'session1',
+        config: {
+          model: LanguageModel.GPT4,
+          params: {},
+        },
+      };
+
+      const expectedState = produce(state, (draft) => {
+        draft.session1.config = {
+          model: LanguageModel.GPT4,
+          params: {},
+          systemRole: 'system',
+        };
+      });
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual(expectedState);
+    });
+
+    it('should not change state when invalid session ID is provided for updating session agent config', () => {
+      const state: LobeSessions = {
+        session1: {
+          id: 'session1',
+          config: {
+            model: 'gpt-3.5-turbo',
+            params: {},
+            systemRole: 'system',
+          },
+        } as LobeAgentSession,
+      };
+
+      const payload: SessionDispatch = {
+        type: 'updateSessionConfig',
+        id: 'session2',
+        config: {
+          model: LanguageModel.GPT4,
+          params: {},
+        },
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual(state);
+    });
+
+    it.skip('should not change state when invalid session agent config is provided for updating session agent config', () => {
+      const state: LobeSessions = {
+        session1: {
+          id: 'session1',
+          config: {
+            model: 'gpt-3.5-turbo',
+            params: {},
+            systemRole: 'system',
+          },
+        } as LobeAgentSession,
+      };
+
+      const payload: SessionDispatch = {
+        type: 'updateSessionConfig',
+        id: 'session1',
+        config: {
+          model: LanguageModel.GPT4,
+          params: {},
+          invalidKey: 'invalidValue',
+        } as unknown as LobeAgentConfig,
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual(state);
+    });
+  });
+
+  test('should not change state when invalid operation type is provided', () => {
+    const state: LobeSessions = {
+      session1: {
+        id: 'session1',
+        config: {
+          model: 'gpt-3.5-turbo',
+          params: {},
+          systemRole: 'system',
+        },
+      } as LobeAgentSession,
+    };
+
+    const payload = {
+      type: 'invalidOperation',
+    } as unknown as SessionDispatch;
+
+    const newState = sessionsReducer(state, payload);
+
+    expect(newState).toEqual(state);
+  });
+
+  describe('updateSessionChat', () => {
+    it('should update session chat correctly', () => {
+      const state: LobeSessions = {
+        session1: {
+          id: 'session1',
+          chats: {},
+        } as LobeAgentSession,
+        session2: {
+          id: 'session2',
+          chats: {},
+        } as LobeAgentSession,
+      };
+
+      const payload: SessionDispatch = {
+        type: 'updateSessionChat',
+        id: 'session1',
+        chats: {
+          message1: {
+            id: 'message1',
+            content: 'Hello',
+          } as ChatMessage,
+        },
+      };
+
+      const expectedState = produce(state, (draft) => {
+        draft.session1.chats = {
+          message1: {
+            id: 'message1',
+            content: 'Hello',
+          } as ChatMessage,
+        };
+      });
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual(expectedState);
+    });
+
+    it('should not change state when invalid session ID is provided for updating session chat', () => {
+      const state: LobeSessions = {
+        session1: {
+          id: 'session1',
+          chats: {},
+        } as LobeAgentSession,
+      };
+
+      const payload: SessionDispatch = {
+        type: 'updateSessionChat',
+        id: 'session2',
+        chats: {
+          message1: {
+            id: 'message1',
+            content: 'Hello',
+          } as ChatMessage,
+        },
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual(state);
+    });
+
+    it.skip('should not change state when invalid chat data is provided for updating session chat', () => {
+      const state: LobeSessions = {
+        session1: {
+          id: 'session1',
+          chats: {},
+        } as LobeAgentSession,
+      };
+
+      const payload: SessionDispatch = {
+        type: 'updateSessionChat',
+        id: 'session1',
+        chats: {
+          message1: {
+            id: 'message1',
+            content: 'Hello',
+            invalidKey: 'invalidValue',
+          } as unknown as ChatMessage,
+        },
+      };
+
+      const newState = sessionsReducer(state, payload);
+
+      expect(newState).toEqual(state);
+    });
+  });
+});

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

@@ -0,0 +1,113 @@
+import { produce } from 'immer';
+
+import { ChatMessageMap } from '@/types/chatMessage';
+import { MetaData } from '@/types/meta';
+import { LobeAgentConfig, LobeAgentSession, LobeSessions } from '@/types/session';
+
+/**
+ * @title 添加会话
+ */
+interface AddSession {
+  /**
+   * @param session - 会话信息
+   */
+  session: LobeAgentSession;
+  /**
+   * @param type - 操作类型
+   * @default 'addChat'
+   */
+  type: 'addSession';
+}
+
+interface RemoveSession {
+  id: string;
+  type: 'removeSession';
+}
+
+/**
+ * @title 更新会话聊天上下文
+ */
+interface UpdateSessionChat {
+  chats: ChatMessageMap;
+  /**
+   * 会话 ID
+   */
+  id: string;
+
+  type: 'updateSessionChat';
+}
+
+interface UpdateSessionMeta {
+  id: string;
+  key: keyof MetaData;
+  type: 'updateSessionMeta';
+  value: any;
+}
+
+interface UpdateSessionAgentConfig {
+  config: Partial<LobeAgentConfig>;
+  id: string;
+  type: 'updateSessionConfig';
+}
+
+export type SessionDispatch =
+  | AddSession
+  | UpdateSessionChat
+  | RemoveSession
+  | UpdateSessionMeta
+  | UpdateSessionAgentConfig;
+
+export const sessionsReducer = (state: LobeSessions, payload: SessionDispatch): LobeSessions => {
+  switch (payload.type) {
+    case 'addSession': {
+      return produce(state, (draft) => {
+        const { session } = payload;
+        if (!session) return;
+
+        draft[session.id] = session;
+      });
+    }
+
+    case 'removeSession': {
+      return produce(state, (draft) => {
+        delete draft[payload.id];
+      });
+    }
+
+    case 'updateSessionMeta': {
+      return produce(state, (draft) => {
+        const chat = draft[payload.id];
+        if (!chat) return;
+
+        const { key, value } = payload;
+
+        const validKeys = ['avatar', 'backgroundColor', 'description', 'tag', 'title'];
+
+        if (validKeys.includes(key)) chat.meta[key] = value;
+      });
+    }
+
+    case 'updateSessionChat': {
+      return produce(state, (draft) => {
+        const chat = draft[payload.id];
+        if (!chat) return;
+
+        chat.chats = payload.chats;
+      });
+    }
+
+    case 'updateSessionConfig': {
+      return produce(state, (draft) => {
+        const { id, config } = payload;
+        const chat = draft[id];
+        if (!chat) return;
+
+        chat.config = { ...chat.config, ...config };
+      });
+    }
+
+    default: {
+      return produce(state, () => {});
+    }
+  }
+};

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

@@ -0,0 +1,4 @@
+import { DEFAULT_AVATAR } from '@/store/session/slices/agentConfig';
+import { MetaData } from '@/types/meta';
+
+export const getAgentAvatar = (s: MetaData) => s.avatar || DEFAULT_AVATAR;

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

@@ -0,0 +1,20 @@
+import { getAgentAvatar } from './chat';
+import {
+  chatListSel,
+  currentSessionSafe,
+  currentSessionSel,
+  getSessionById,
+  getSessionMetaById,
+} from './list';
+
+export const sessionSelectors = {
+  chatList: chatListSel,
+  currentSession: currentSessionSel,
+  currentSessionSafe,
+
+  getAgentAvatar,
+
+  getSessionById,
+  // sessionTree: sessionTreeSel,
+  getSessionMetaById,
+};

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

@@ -0,0 +1,65 @@
+import { SessionStore } from '@/store/session';
+import { MetaData } from '@/types/meta';
+import { LobeAgentSession } from '@/types/session';
+import { filterWithKeywords } from '@/utils/filter';
+
+import { initLobeSession } from '../initialState';
+
+export const currentSessionSel = (s: SessionStore): LobeAgentSession | undefined => {
+  if (!s.activeId) return;
+
+  return s.sessions[s.activeId];
+};
+export const currentSessionSafe = (s: SessionStore): LobeAgentSession => {
+  return currentSessionSel(s) || initLobeSession;
+};
+
+export const chatListSel = (s: SessionStore) => {
+  const filterChats = filterWithKeywords(s.sessions, s.searchKeywords, (item) => [
+    Object.values(item.chats)
+      .map((c) => c.content)
+      .join(''),
+  ]);
+
+  return Object.values(filterChats).sort((a, b) => (b.updateAt || 0) - (a.updateAt || 0));
+};
+
+export const getSessionById =
+  (id: string) =>
+  (s: SessionStore): LobeAgentSession => {
+    const session = s.sessions[id];
+
+    if (!session) return initLobeSession;
+    return session;
+  };
+
+export const getSessionMetaById =
+  (id: string) =>
+  (s: SessionStore): MetaData => {
+    const session = s.sessions[id];
+
+    if (!session) return {};
+    return session.meta;
+  };
+
+// export const sessionTreeSel = (s: SessionStore) => {
+//   const sessionTree: SessionTree = [
+//     {
+//       agentId: 'default',
+//       chats: chatListSel(s)
+//         .filter((s) => !s.agentId)
+//         .map((c) => c.id),
+//     },
+//   ];
+//
+//   Object.values(s.agents).forEach((agent) => {
+//     const chats = Object.values(s.chats).filter((s) => s.agentId === agent.id);
+//
+//     sessionTree.push({
+//       agentId: agent.id,
+//       chats: chats.map((c) => c.id),
+//     });
+//   });
+//
+//   return sessionTree;
+// };

package/src/store/session/store.ts

@@ -0,0 +1,17 @@
+import { StateCreator } from 'zustand/vanilla';
+
+import { SessionStoreState, initialState } from './initialState';
+import { AgentAction, createAgentSlice } from './slices/agentConfig';
+import { ChatAction, createChatSlice } from './slices/chat';
+import { SessionAction, createSessionSlice } from './slices/session';
+
+export type SessionStore = SessionAction & AgentAction & ChatAction & SessionStoreState;
+
+export const createStore: StateCreator<SessionStore, [['zustand/devtools', never]]> = (
+  ...parameters
+) => ({
+  ...initialState,
+  ...createAgentSlice(...parameters),
+  ...createSessionSlice(...parameters),
+  ...createChatSlice(...parameters),
+});

package/src/store/settings/action.ts

@@ -0,0 +1,31 @@
+import { merge } from 'lodash-es';
+import type { StateCreator } from 'zustand/vanilla';
+
+import type { ConfigSettings } from '@/types/exportConfig';
+
+import type { SidebarTabKey } from './initialState';
+import { SettingsState } from './initialState';
+import type { SettingsStore } from './store';
+
+export interface SettingsAction {
+  importSettings: (settings: SettingsState) => void;
+  saveSettings: (settings: ConfigSettings) => void;
+  switchSideBar: (key: SidebarTabKey) => void;
+}
+
+export const createSettings: StateCreator<
+  SettingsStore,
+  [['zustand/devtools', never]],
+  [],
+  SettingsAction
+> = (set, get) => ({
+  importSettings: (settings) => {
+    set({ ...settings });
+  },
+  saveSettings: (settings) => {
+    set({ settings: merge(get().settings, settings) });
+  },
+  switchSideBar: (key) => {
+    set({ sidebarKey: key });
+  },
+});