@lobehub/chat 0.42.3 → 0.44.0

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

@@ -2,12 +2,14 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { LOADING_FLAT } from '@/const/message';
 import { promptSummaryTitle } from '@/prompts/chat';
-import { SessionStore, chatSelectors, sessionSelectors, topicSelectors } from '@/store/session';
+import { SessionStore } from '@/store/session';
 import { fetchPresetTaskResult } from '@/utils/fetch';
 import { setNamespace } from '@/utils/storeDebug';
 import { nanoid } from '@/utils/uuid';
 
+import { sessionSelectors } from '../../session/selectors';
 import { ChatTopicDispatch, topicReducer } from '../reducers/topic';
+import { chatSelectors, topicSelectors } from '../selectors';
 
 const t = setNamespace('chat/topic');
 export interface ChatTopicAction {

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

@@ -4,7 +4,7 @@ import { ChatMessage } from '@/types/chatMessage';
 
 import type { SessionStore } from '../../../store';
 import { agentSelectors } from '../../agentConfig';
-import { sessionSelectors } from '../../session';
+import { sessionSelectors } from '../../session/selectors';
 import { getSlicedMessagesWithConfig } from '../utils';
 import { organizeChats } from './utils';
 

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

@@ -1,6 +1,6 @@
 import { encode } from 'gpt-tokenizer';
 
-import { agentSelectors } from '@/store/session';
+import { agentSelectors } from '@/store/session/slices/agentConfig';
 
 import type { SessionStore } from '../../../store';
 import { currentChatsWithHistoryConfig } from './chat';

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

@@ -1,8 +1,10 @@
 // 展示在聊天框中的消息
-import { SessionStore, sessionSelectors } from '@/store/session';
-import { organizeChats } from '@/store/session/slices/chat/selectors/utils';
 import { ChatTopic } from '@/types/topic';
 
+import { SessionStore } from '../../../store';
+import { sessionSelectors } from '../../session/selectors';
+import { organizeChats } from './utils';
+
 export const currentTopics = (s: SessionStore): ChatTopic[] => {
   const session = sessionSelectors.currentSession(s);
   if (!session) return [];

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

@@ -3,19 +3,21 @@ import { merge } from 'lodash-es';
 import Router from 'next/router';
 import { StateCreator } from 'zustand/vanilla';
 
+import { INBOX_SESSION_ID } from '@/const/session';
 import { useGlobalStore } from '@/store/global';
-import { SessionStore, initLobeSession } from '@/store/session';
+import { SessionStore } from '@/store/session';
 import { LobeAgentSession, LobeSessions } from '@/types/session';
 import { setNamespace } from '@/utils/storeDebug';
 import { uuid } from '@/utils/uuid';
 
+import { initLobeSession } from './initialState';
 import { SessionDispatch, sessionsReducer } from './reducers/session';
 
 const t = setNamespace('session');
+
 export interface SessionAction {
   activeSession: (sessionId: string) => void;
   clearSessions: () => void;
-
   /**
    * @title 添加会话
    * @param session - 会话信息
@@ -27,7 +29,6 @@ export interface SessionAction {
    * @param payload - 聊天记录
    */
   dispatchSession: (payload: SessionDispatch) => void;
-
   /**
    * 导入会话
    * @param sessions
@@ -39,6 +40,7 @@ export interface SessionAction {
    * @param sessionId
    */
   pinSession: (sessionId: string, pinned?: boolean) => void;
+
   /**
    * 生成压缩后的消息
    * @returns 压缩后的消息
@@ -50,6 +52,7 @@ export interface SessionAction {
    * @returns void
    */
   removeSession: (sessionId: string) => void;
+  switchInbox: () => void;
 
   /**
    * @title 切换会话
@@ -95,11 +98,21 @@ export const createSessionSlice: StateCreator<
 
   dispatchSession: (payload) => {
     const { type, ...res } = payload;
-    set(
-      { sessions: sessionsReducer(get().sessions, payload) },
-      false,
-      t(`dispatchChat/${type}`, res),
-    );
+
+    // 如果是 inbox 类型的 session
+    if ('id' in res && res.id === INBOX_SESSION_ID) {
+      const nextInbox = sessionsReducer({ inbox: get().inbox }, payload) as {
+        inbox: LobeAgentSession;
+      };
+      set({ inbox: nextInbox.inbox }, false, t(`dispatchInbox/${type}`, res));
+    } else {
+      // 常规类型的session
+      set(
+        { sessions: sessionsReducer(get().sessions, payload) },
+        false,
+        t(`dispatchSessions/${type}`, res),
+      );
+    }
   },
 
   importSessions: (importSessions) => {
@@ -119,13 +132,7 @@ export const createSessionSlice: StateCreator<
       t('importSessions', importSessions),
     );
   },
-  // genShareUrl: () => {
-  //   const session = sessionSelectors.currentSession(get());
-  //   if (!session) return '';
-  //
-  //   const agent = session.config;
-  //   return genShareMessagesUrl(session.chats, agent.systemRole);
-  // },
+
   pinSession: (sessionId, pinned) => {
     const nextValue = typeof pinned === 'boolean' ? pinned : !get().sessions[sessionId].pinned;
 
@@ -140,6 +147,13 @@ export const createSessionSlice: StateCreator<
     }
   },
 
+  switchInbox: () => {
+    if (get().activeId === INBOX_SESSION_ID) return;
+    get().activeSession(INBOX_SESSION_ID);
+
+    Router.push('/chat');
+  },
+
   switchSession: async (sessionId) => {
     if (get().activeId === sessionId) return;
 

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

@@ -1,7 +1,9 @@
-import { DEFAULT_AGENT_META } from '@/const/meta';
-import { LobeAgentSession, LobeSessionType } from '@/types/session';
+import { merge } from 'lodash-es';
 
-import { initialLobeAgentConfig } from '../agentConfig';
+import { DEFAULT_AGENT_META, DEFAULT_INBOX_AVATAR } from '@/const/meta';
+import { LobeAgentConfig, LobeAgentSession, LobeSessionType } from '@/types/session';
+
+import { initialLobeAgentConfig } from '../agentConfig/initialState';
 
 export interface SessionState {
   /**
@@ -10,6 +12,8 @@ export interface SessionState {
    * @default null
    */
   activeId: string | null;
+  // 默认会话
+  inbox: LobeAgentSession;
   searchKeywords: string;
   sessions: Record<string, LobeAgentSession>;
 }
@@ -24,9 +28,19 @@ export const initLobeSession: LobeAgentSession = {
   updateAt: Date.now(),
 };
 
+export const initInbox = merge({}, initLobeSession, {
+  config: {
+    systemRole: '你是一名 AI 助理',
+  } as LobeAgentConfig,
+  id: 'inbox',
+  meta: {
+    avatar: DEFAULT_INBOX_AVATAR,
+  },
+} as Partial<LobeAgentSession>);
+
 export const initialSessionState: SessionState = {
   activeId: null,
-
+  inbox: initInbox,
   searchKeywords: '',
   sessions: {},
 };

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

@@ -1,20 +1,25 @@
 import { transform } from 'lodash-es';
 
 import { SessionStore } from '@/store/session';
+import { ConfigStateAgents, ConfigStateSessions } from '@/types/exportConfig';
 import { LobeAgentSession, LobeSessions } from '@/types/session';
 
 import { getSessionById } from './list';
 
-export const exportSessions = (s: SessionStore) => s.sessions;
+export const exportSessions = (s: SessionStore): ConfigStateSessions => ({
+  inbox: s.inbox,
+  sessions: s.sessions,
+});
 
-// 排除 chats
-export const exportAgents = (s: SessionStore) => {
-  return transform(s.sessions, (result: LobeSessions, value, key) => {
-    // 移除 chats 和 topics
-    result[key] = { ...value, chats: {}, topics: {} } as LobeAgentSession;
-  });
+export const exportAgents = (s: SessionStore): ConfigStateAgents => {
+  return {
+    sessions: transform(s.sessions, (result: LobeSessions, value, key) => {
+      // 移除 chats 和 topics
+      result[key] = { ...value, chats: {}, topics: {} } as LobeAgentSession;
+    }),
+  };
 };
-// 排除 chats
+
 export const getExportAgent =
   (id: string) =>
   (s: SessionStore): LobeAgentSession => {

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

@@ -0,0 +1,303 @@
+import type { SessionStore } from '@/store/session';
+import { LanguageModel } from '@/types/llm';
+import { LobeAgentSession, LobeSessionType } from '@/types/session';
+
+import { initLobeSession } from '../initialState';
+import {
+  currentSession,
+  currentSessionSafe,
+  getSessionById,
+  getSessionMetaById,
+  hasSessionList,
+  sessionList,
+} from './list';
+
+describe('currentSession', () => {
+  const s = {
+    activeId: '1',
+    sessions: {
+      '1': {
+        id: '1',
+        config: {
+          model: LanguageModel.GPT3_5,
+          params: {},
+          systemRole: 'system-role',
+        },
+        type: LobeSessionType.Agent,
+      } as LobeAgentSession,
+      '2': {
+        id: '2',
+        config: {
+          model: LanguageModel.GPT3_5,
+          params: {},
+          systemRole: 'system-role',
+        },
+        type: LobeSessionType.Agent,
+      } as LobeAgentSession,
+    },
+    inbox: {
+      id: 'inbox',
+      config: {
+        model: LanguageModel.GPT3_5,
+        params: {},
+        systemRole: 'system-role',
+      },
+      type: LobeSessionType.Agent,
+    } as LobeAgentSession,
+  } as unknown as SessionStore;
+
+  it('should return undefined when s.activeId is not defined', () => {
+    expect(currentSession({ sessions: {} } as any)).toBeUndefined();
+  });
+
+  it('should return s.inbox when s.activeId is equal to INBOX_SESSION_ID', () => {
+    expect(currentSession({ ...s, activeId: 'inbox' })).toEqual(s.inbox);
+  });
+
+  it('should return s.sessions[s.activeId] when s.activeId is not equal to INBOX_SESSION_ID', () => {
+    expect(currentSession(s)).toEqual(s.sessions['1']);
+  });
+});
+
+describe('currentSessionSafe', () => {
+  const s = {
+    activeId: '1',
+    sessions: {
+      '1': {
+        id: '1',
+        config: {
+          model: LanguageModel.GPT3_5,
+          params: {},
+          systemRole: 'system-role',
+        },
+        type: LobeSessionType.Agent,
+      } as LobeAgentSession,
+      '2': {
+        id: '2',
+        config: {
+          model: LanguageModel.GPT3_5,
+          params: {},
+          systemRole: 'system-role',
+        },
+        type: LobeSessionType.Agent,
+      } as LobeAgentSession,
+    },
+    inbox: {
+      id: 'inbox',
+      config: {
+        model: LanguageModel.GPT3_5,
+        params: {},
+        systemRole: 'system-role',
+      },
+      type: LobeSessionType.Agent,
+    } as LobeAgentSession,
+  } as unknown as SessionStore;
+
+  it('should return initLobeSession when currentSession(s) returns undefined', () => {
+    expect(currentSessionSafe({ sessions: {} } as any)).toEqual(initLobeSession);
+  });
+
+  it('should return the result of currentSession(s) when it returns a non-undefined value', () => {
+    expect(currentSessionSafe(s)).toEqual(s.sessions['1']);
+  });
+});
+
+describe('sessionList', () => {
+  const s = {
+    sessions: {
+      '1': {
+        pinned: true,
+        updateAt: 100,
+      },
+      '2': {
+        pinned: false,
+        updateAt: 200,
+      },
+      '3': {
+        pinned: true,
+        updateAt: 300,
+      },
+    },
+  } as unknown as SessionStore;
+
+  it('should return an array of sessions sorted by pinned and updateAt fields', () => {
+    expect(sessionList(s)).toEqual([s.sessions['3'], s.sessions['1'], s.sessions['2']]);
+  });
+
+  it('should return an empty array when s.sessions is an empty object', () => {
+    const result = sessionList({
+      sessions: {},
+    } as any);
+    expect(result).toEqual([]);
+  });
+
+  it('should return a sorted session list when s.sessions is not empty object', () => {
+    const session1 = {
+      id: '1',
+      pinned: true,
+      updateAt: 1635705600000,
+      meta: {},
+    };
+    const session2 = {
+      id: '2',
+      pinned: false,
+      updateAt: 1635705600000,
+      meta: {},
+    };
+    const session3 = {
+      id: '3',
+      pinned: true,
+      updateAt: 1635705700000,
+      meta: {},
+    };
+    const s = {
+      sessions: {
+        '1': session1,
+        '2': session2,
+        '3': session3,
+      },
+    } as unknown as SessionStore;
+    const result = sessionList(s);
+    expect(result).toEqual([session3, session1, session2]);
+  });
+
+  it('should return a sorted session list when s.searchKeywords is not an empty string', () => {
+    const session1 = {
+      id: '1',
+      pinned: true,
+      meta: { title: 'yword' },
+
+      updateAt: 1635705600000,
+    };
+    const session2 = {
+      id: '2',
+      pinned: false,
+      meta: { title: 'keyword' },
+      updateAt: 1635705600000,
+    };
+    const session3 = {
+      id: '3',
+      pinned: true,
+      meta: { title: 'kyword' },
+      updateAt: 1635705800000,
+    };
+    const s = {
+      sessions: {
+        '1': session1,
+        '2': session2,
+        '3': session3,
+      },
+      searchKeywords: 'k',
+    } as unknown as SessionStore;
+
+    const result = sessionList(s);
+    expect(result).toEqual([session3, session2]);
+  });
+
+  it('should return an empty array when s.sessions is an empty object and s.searchKeywords is not an empty string', () => {
+    const result = sessionList({
+      sessions: {},
+      searchKeywords: 'keyword',
+    } as unknown as SessionStore);
+    expect(result).toEqual([]);
+  });
+});
+
+describe('hasSessionList', () => {
+  it('should return true when sessionList(s) returns a non-empty array', () => {
+    const s = {
+      sessions: {
+        '1': {},
+      },
+    } as unknown as SessionStore;
+    expect(hasSessionList(s)).toBe(true);
+  });
+
+  it('should return false when sessionList(s) returns an empty array', () => {
+    const s = {
+      sessions: {},
+    } as unknown as SessionStore;
+    expect(hasSessionList(s)).toBe(false);
+  });
+});
+
+describe('getSessionById', () => {
+  const s = {
+    activeId: '1',
+    sessions: {
+      '1': {
+        id: '1',
+        config: {
+          model: LanguageModel.GPT3_5,
+          params: {},
+          systemRole: 'system-role',
+        },
+        type: LobeSessionType.Agent,
+      } as LobeAgentSession,
+      '2': {
+        id: '2',
+        config: {
+          model: LanguageModel.GPT3_5,
+          params: {},
+          systemRole: 'system-role',
+        },
+        type: LobeSessionType.Agent,
+      } as LobeAgentSession,
+    },
+    inbox: {
+      id: 'inbox',
+      config: {
+        model: LanguageModel.GPT3_5,
+        params: {},
+        systemRole: 'system-role',
+      },
+      type: LobeSessionType.Agent,
+    } as LobeAgentSession,
+  } as unknown as SessionStore;
+
+  it('should return s.inbox when id is equal to INBOX_SESSION_ID', () => {
+    expect(getSessionById('inbox')(s)).toEqual(s.inbox);
+  });
+
+  it('should return the session with the specified id when id is not equal to INBOX_SESSION_ID', () => {
+    expect(getSessionById('1')(s)).toEqual(s.sessions['1']);
+  });
+
+  it('should return initLobeSession when the session with the specified id does not exist', () => {
+    expect(getSessionById('3')(s)).toEqual(initLobeSession);
+  });
+});
+
+describe('getSessionMetaById', () => {
+  const s: SessionStore = {
+    sessions: {
+      '1': {
+        meta: {
+          title: 'Session 1',
+        },
+      },
+      '2': {
+        meta: {
+          title: 'Session 2',
+        },
+      },
+    },
+    inbox: {
+      meta: {
+        title: 'Inbox',
+      },
+    },
+  } as unknown as SessionStore;
+
+  it('should return the meta data of the session with the specified id', () => {
+    expect(getSessionMetaById('1')(s)).toEqual({ title: 'Session 1' });
+  });
+
+  it('should return the meta data of the inbox session when id is equal to INBOX_SESSION_ID', () => {
+    expect(getSessionMetaById('inbox')(s)).toEqual({ title: 'Inbox' });
+  });
+
+  it('should return an empty object when the session with the specified id does not exist', () => {
+    expect(getSessionMetaById('3')(s)).toEqual({});
+  });
+});

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

@@ -1,13 +1,16 @@
-import { SessionStore } from '@/store/session';
+import { INBOX_SESSION_ID } from '@/const/session';
 import { MetaData } from '@/types/meta';
 import { LobeAgentSession } from '@/types/session';
 import { filterWithKeywords } from '@/utils/filter';
 
+import { SessionStore } from '../../../store';
 import { initLobeSession } from '../initialState';
 
 export const currentSession = (s: SessionStore): LobeAgentSession | undefined => {
   if (!s.activeId) return;
 
+  if (s.activeId === INBOX_SESSION_ID) return s.inbox;
+
   return s.sessions[s.activeId];
 };
 
@@ -17,7 +20,7 @@ export const currentSessionSafe = (s: SessionStore): LobeAgentSession => {
 
 export const sessionList = (s: SessionStore) => {
   const filterChats = filterWithKeywords(s.sessions, s.searchKeywords, (item) => [
-    Object.values(item.chats)
+    Object.values(item.chats || {})
       .map((c) => c.content)
       .join(''),
   ]);
@@ -44,6 +47,8 @@ export const hasSessionList = (s: SessionStore) => {
 export const getSessionById =
   (id: string) =>
   (s: SessionStore): LobeAgentSession => {
+    if (id === INBOX_SESSION_ID) return s.inbox;
+
     const session = s.sessions[id];
 
     if (!session) return initLobeSession;
@@ -53,7 +58,7 @@ export const getSessionById =
 export const getSessionMetaById =
   (id: string) =>
   (s: SessionStore): MetaData => {
-    const session = s.sessions[id];
+    const session = getSessionById(id)(s);
 
     if (!session) return {};
     return session.meta;

package/src/store/session/store.ts

@@ -6,9 +6,9 @@ import { StateCreator } from 'zustand/vanilla';
 import { isDev } from '@/utils/env';
 
 import { SessionStoreState, initialState } from './initialState';
-import { AgentAction, createAgentSlice } from './slices/agentConfig';
-import { ChatAction, createChatSlice } from './slices/chat';
-import { SessionAction, createSessionSlice } from './slices/session';
+import { AgentAction, createAgentSlice } from './slices/agentConfig/action';
+import { ChatAction, createChatSlice } from './slices/chat/actions';
+import { SessionAction, createSessionSlice } from './slices/session/action';
 
 //  ===============  聚合 createStoreFn ============ //
 
@@ -23,7 +23,7 @@ const createStore: StateCreator<SessionStore, [['zustand/devtools', never]]> = (
 
 //  ===============  persist 本地缓存中间件配置 ============ //
 
-type SessionPersist = Pick<SessionStore, 'sessions'>;
+type SessionPersist = Pick<SessionStore, 'sessions' | 'inbox'>;
 
 const LOBE_CHAT = 'LOBE_CHAT';
 
@@ -31,13 +31,13 @@ const persistOptions: PersistOptions<SessionStore, SessionPersist> = {
   name: LOBE_CHAT,
 
   partialize: (s) => ({
+    inbox: s.inbox,
     sessions: s.sessions,
   }),
 
   // 手动控制 Hydration ，避免 ssr 报错
   skipHydration: true,
   version: 0,
-  // version: Migration.targetVersion,
 };
 
 //  ===============  实装 useStore ============ //