@lobehub/chat 0.149.3 → 0.149.5

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

@@ -0,0 +1,81 @@
+import { VoiceList } from '@lobehub/tts';
+
+import { INBOX_SESSION_ID } from '@/const/session';
+import { DEFAULT_AGENT_CONFIG, DEFAUTT_AGENT_TTS_CONFIG } from '@/const/settings';
+import { AgentStore } from '@/store/agent';
+import { LobeAgentTTSConfig } from '@/types/agent';
+import { merge } from '@/utils/merge';
+
+const isInboxSession = (s: AgentStore) => s.activeId === INBOX_SESSION_ID;
+
+// ==========   Config   ============== //
+const currentAgentConfig = (s: AgentStore) => merge(DEFAULT_AGENT_CONFIG, s.agentConfig);
+
+const currentAgentSystemRole = (s: AgentStore) => {
+  return currentAgentConfig(s).systemRole;
+};
+
+const currentAgentModel = (s: AgentStore): string => {
+  const config = currentAgentConfig(s);
+
+  return config?.model || 'gpt-3.5-turbo';
+};
+
+const currentAgentModelProvider = (s: AgentStore) => {
+  const config = currentAgentConfig(s);
+
+  return config?.provider;
+};
+
+const currentAgentPlugins = (s: AgentStore) => {
+  const config = currentAgentConfig(s);
+
+  return config?.plugins || [];
+};
+
+const currentAgentTTS = (s: AgentStore): LobeAgentTTSConfig => {
+  const config = currentAgentConfig(s);
+
+  return config?.tts || DEFAUTT_AGENT_TTS_CONFIG;
+};
+
+const currentAgentTTSVoice =
+  (lang: string) =>
+  (s: AgentStore): string => {
+    const { voice, ttsService } = currentAgentTTS(s);
+    const voiceList = new VoiceList(lang);
+    let currentVoice;
+    switch (ttsService) {
+      case 'openai': {
+        currentVoice = voice.openai || (VoiceList.openaiVoiceOptions?.[0].value as string);
+        break;
+      }
+      case 'edge': {
+        currentVoice = voice.edge || (voiceList.edgeVoiceOptions?.[0].value as string);
+        break;
+      }
+      case 'microsoft': {
+        currentVoice = voice.microsoft || (voiceList.microsoftVoiceOptions?.[0].value as string);
+        break;
+      }
+    }
+    return currentVoice || 'alloy';
+  };
+
+const hasSystemRole = (s: AgentStore) => {
+  const config = currentAgentConfig(s);
+
+  return !!config.systemRole;
+};
+
+export const agentSelectors = {
+  currentAgentConfig,
+  currentAgentModel,
+  currentAgentModelProvider,
+  currentAgentPlugins,
+  currentAgentSystemRole,
+  currentAgentTTS,
+  currentAgentTTSVoice,
+  hasSystemRole,
+  isInboxSession,
+};

package/src/store/agent/store.ts

@@ -0,0 +1,27 @@
+import { devtools } from 'zustand/middleware';
+import { shallow } from 'zustand/shallow';
+import { createWithEqualityFn } from 'zustand/traditional';
+import { StateCreator } from 'zustand/vanilla';
+
+import { isDev } from '@/utils/env';
+
+import { SessionStoreState, initialState } from './initialState';
+import { AgentChatAction, createChatSlice } from './slices/chat/action';
+
+//  ===============  aggregate createStoreFn ============ //
+
+export interface AgentStore extends AgentChatAction, SessionStoreState {}
+
+const createStore: StateCreator<AgentStore, [['zustand/devtools', never]]> = (...parameters) => ({
+  ...initialState,
+  ...createChatSlice(...parameters),
+});
+
+//  ===============  implement useStore ============ //
+
+export const useAgentStore = createWithEqualityFn<AgentStore>()(
+  devtools(createStore, {
+    name: 'LobeChat_Agent' + (isDev ? '_DEV' : ''),
+  }),
+  shallow,
+);

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

@@ -7,8 +7,9 @@ import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { chatService } from '@/services/chat';
 import { messageService } from '@/services/message';
 import { topicService } from '@/services/topic';
+import { agentSelectors } from '@/store/agent/selectors';
 import { chatSelectors } from '@/store/chat/selectors';
-import { agentSelectors } from '@/store/session/selectors';
+import { sessionMetaSelectors } from '@/store/session/selectors';
 import { ChatMessage } from '@/types/message';
 
 import { useChatStore } from '../../store';
@@ -69,7 +70,7 @@ beforeEach(() => {
   vi.clearAllMocks();
   useChatStore.setState(mockState, false);
   vi.spyOn(agentSelectors, 'currentAgentConfig').mockImplementation(() => DEFAULT_AGENT_CONFIG);
-  vi.spyOn(agentSelectors, 'currentAgentMeta').mockImplementation(() => ({ tags: [] }));
+  vi.spyOn(sessionMetaSelectors, 'currentAgentMeta').mockImplementation(() => ({ tags: [] }));
 });
 
 afterEach(() => {

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

@@ -13,10 +13,10 @@ import { chatService } from '@/services/chat';
 import { CreateMessageParams, messageService } from '@/services/message';
 import { topicService } from '@/services/topic';
 import { traceService } from '@/services/trace';
+import { useAgentStore } from '@/store/agent';
+import { agentSelectors } from '@/store/agent/selectors';
 import { chatHelpers } from '@/store/chat/helpers';
 import { ChatStore } from '@/store/chat/store';
-import { useSessionStore } from '@/store/session';
-import { agentSelectors } from '@/store/session/selectors';
 import { ChatMessage } from '@/types/message';
 import { TraceEventPayloads } from '@/types/trace';
 import { setNamespace } from '@/utils/storeDebug';
@@ -120,7 +120,7 @@ export interface ChatMessageAction {
   internalTraceMessage: (id: string, payload: TraceEventPayloads) => Promise<void>;
 }
 
-const getAgentConfig = () => agentSelectors.currentAgentConfig(useSessionStore.getState());
+const getAgentConfig = () => agentSelectors.currentAgentConfig(useAgentStore.getState());
 
 const preventLeavingFn = (e: BeforeUnloadEvent) => {
   // set returnValue to trigger alert modal

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

@@ -3,10 +3,12 @@ import { describe, expect, it } from 'vitest';
 
 import { DEFAULT_INBOX_AVATAR } from '@/const/meta';
 import { INBOX_SESSION_ID } from '@/const/session';
+import { useAgentStore } from '@/store/agent';
 import { ChatStore } from '@/store/chat';
 import { initialState } from '@/store/chat/initialState';
 import { useGlobalStore } from '@/store/global';
 import { useSessionStore } from '@/store/session';
+import { LobeAgentConfig } from '@/types/agent';
 import { ChatMessage } from '@/types/message';
 import { MetaData } from '@/types/meta';
 import { merge } from '@/utils/merge';
@@ -158,8 +160,13 @@ describe('chatSelectors', () => {
     it('should slice the messages according to config, assuming historyCount is mocked to 2', async () => {
       const state = merge(initialStore, { messages: mockMessages });
       act(() => {
-        useGlobalStore.setState({
-          settings: { defaultAgent: { config: { historyCount: 2, enableHistoryCount: true } } },
+        useAgentStore.setState({
+          activeId: 'inbox',
+          agentConfig: {
+            historyCount: 2,
+            enableHistoryCount: true,
+            model: 'abc',
+          } as LobeAgentConfig,
         });
       });
 

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

@@ -3,10 +3,12 @@ import { t } from 'i18next';
 
 import { DEFAULT_INBOX_AVATAR, DEFAULT_USER_AVATAR } from '@/const/meta';
 import { INBOX_SESSION_ID } from '@/const/session';
+import { useAgentStore } from '@/store/agent';
+import { agentSelectors } from '@/store/agent/selectors';
 import { useGlobalStore } from '@/store/global';
 import { commonSelectors } from '@/store/global/selectors';
 import { useSessionStore } from '@/store/session';
-import { agentSelectors } from '@/store/session/selectors';
+import { sessionMetaSelectors } from '@/store/session/selectors';
 import { ChatMessage } from '@/types/message';
 import { MetaData } from '@/types/meta';
 import { merge } from '@/utils/merge';
@@ -27,7 +29,7 @@ const getMeta = (message: ChatMessage) => {
     }
 
     case 'assistant': {
-      return agentSelectors.currentAgentMeta(useSessionStore.getState());
+      return sessionMetaSelectors.currentAgentMeta(useSessionStore.getState());
     }
 
     case 'function': {
@@ -88,14 +90,14 @@ const currentChatsWithGuideMessage =
   };
 
 const currentChatIDsWithGuideMessage = (s: ChatStore) => {
-  const meta = agentSelectors.currentAgentMeta(useSessionStore.getState());
+  const meta = sessionMetaSelectors.currentAgentMeta(useSessionStore.getState());
 
   return currentChatsWithGuideMessage(meta)(s).map((s) => s.id);
 };
 
 const currentChatsWithHistoryConfig = (s: ChatStore): ChatMessage[] => {
   const chats = currentChats(s);
-  const config = agentSelectors.currentAgentConfig(useSessionStore.getState());
+  const config = agentSelectors.currentAgentConfig(useAgentStore.getState());
 
   return chatHelpers.getSlicedMessagesWithConfig(chats, config);
 };

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

@@ -4,8 +4,10 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { DEFAULT_USER_AVATAR_URL } from '@/const/meta';
 import { shareGPTService } from '@/services/share';
+import { useAgentStore } from '@/store/agent';
+import { agentSelectors } from '@/store/agent/selectors';
 import { useSessionStore } from '@/store/session';
-import { agentSelectors } from '@/store/session/selectors';
+import { sessionMetaSelectors } from '@/store/session/selectors';
 import { ShareGPTConversation } from '@/types/share';
 
 import { chatSelectors } from '../../selectors';
@@ -56,8 +58,8 @@ export const chatShare: StateCreator<ChatStore, [['zustand/devtools', never]], [
 ) => ({
   shareToShareGPT: async ({ withSystemRole, withPluginInfo, avatar }) => {
     const messages = chatSelectors.currentChats(get());
-    const config = agentSelectors.currentAgentConfig(useSessionStore.getState());
-    const meta = agentSelectors.currentAgentMeta(useSessionStore.getState());
+    const config = agentSelectors.currentAgentConfig(useAgentStore.getState());
+    const meta = sessionMetaSelectors.currentAgentMeta(useSessionStore.getState());
 
     const defaultMsg: ShareGPTConversation['items'] = [];
     const showSystemRole = withSystemRole && !!config.systemRole;

package/src/store/global/slices/preference/selectors.ts

@@ -1,6 +1,8 @@
 import { GlobalStore } from '@/store/global';
+import { SessionDefaultGroup } from '@/types/session';
 
-const sessionGroupKeys = (s: GlobalStore): string[] => s.preference.expandSessionGroupKeys || [];
+const sessionGroupKeys = (s: GlobalStore): string[] =>
+  s.preference.expandSessionGroupKeys || [SessionDefaultGroup.Pinned, SessionDefaultGroup.Default];
 
 const useCmdEnterToSend = (s: GlobalStore): boolean => s.preference.useCmdEnterToSend || false;
 

package/src/store/session/selectors.ts

@@ -1,3 +1,2 @@
-export { agentSelectors } from './slices/agent/selectors';
-export { sessionSelectors } from './slices/session/selectors';
+export { sessionMetaSelectors, sessionSelectors } from './slices/session/selectors';
 export { sessionGroupSelectors } from './slices/sessionGroup/selectors';

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

@@ -7,6 +7,8 @@ import { sessionService } from '@/services/session';
 import { useSessionStore } from '@/store/session';
 import { LobeSessionType } from '@/types/session';
 
+import { sessionSelectors } from './selectors';
+
 // Mock sessionService 和其他依赖项
 vi.mock('@/services/session', () => ({
   sessionService: {
@@ -189,4 +191,45 @@ describe('SessionAction', () => {
       expect(mockRefresh).toHaveBeenCalled();
     });
   });
+
+  describe('updateAgentMeta', () => {
+    it('should not update meta if there is no current session', async () => {
+      const { result } = renderHook(() => useSessionStore());
+      const meta = { title: 'Test Agent' };
+      const updateSessionMock = vi.spyOn(sessionService, 'updateSession');
+      const refreshSessionsMock = vi.spyOn(result.current, 'refreshSessions');
+
+      // 模拟没有当前会话
+      vi.spyOn(sessionSelectors, 'currentSession').mockReturnValue(null as any);
+
+      await act(async () => {
+        await result.current.updateSessionMeta(meta as any);
+      });
+
+      expect(updateSessionMock).not.toHaveBeenCalled();
+      expect(refreshSessionsMock).not.toHaveBeenCalled();
+      updateSessionMock.mockRestore();
+      refreshSessionsMock.mockRestore();
+    });
+
+    it('should update session meta and refresh sessions', async () => {
+      const { result } = renderHook(() => useSessionStore());
+      const meta = { title: 'Test Agent' };
+      const updateSessionMock = vi.spyOn(sessionService, 'updateSession');
+      const refreshSessionsMock = vi.spyOn(result.current, 'refreshSessions');
+
+      // 模拟有当前会话
+      vi.spyOn(sessionSelectors, 'currentSession').mockReturnValue({ id: 'session-id' } as any);
+      vi.spyOn(result.current, 'activeId', 'get').mockReturnValue('session-id');
+
+      await act(async () => {
+        await result.current.updateSessionMeta(meta);
+      });
+
+      expect(updateSessionMock).toHaveBeenCalledWith('session-id', { meta });
+      expect(refreshSessionsMock).toHaveBeenCalled();
+      updateSessionMock.mockRestore();
+      refreshSessionsMock.mockRestore();
+    });
+  });
 });

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

@@ -1,15 +1,17 @@
 import { t } from 'i18next';
+import { isEqual } from 'lodash-es';
 import useSWR, { SWRResponse, mutate } from 'swr';
 import { DeepPartial } from 'utility-types';
 import { StateCreator } from 'zustand/vanilla';
 
 import { message } from '@/components/AntdStaticMethods';
-import { INBOX_SESSION_ID } from '@/const/session';
-import { SWRRefreshParams, useClientDataSWR } from '@/libs/swr';
+import { DEFAULT_AGENT_LOBE_SESSION, INBOX_SESSION_ID } from '@/const/session';
+import { useClientDataSWR } from '@/libs/swr';
 import { sessionService } from '@/services/session';
 import { useGlobalStore } from '@/store/global';
 import { settingsSelectors } from '@/store/global/selectors';
 import { SessionStore } from '@/store/session';
+import { MetaData } from '@/types/meta';
 import {
   ChatSessionList,
   LobeAgentSession,
@@ -21,10 +23,9 @@ import {
 import { merge } from '@/utils/merge';
 import { setNamespace } from '@/utils/storeDebug';
 
-import { agentSelectors } from '../agent/selectors';
-import { initLobeSession } from './initialState';
 import { SessionDispatch, sessionsReducer } from './reducers';
 import { sessionSelectors } from './selectors';
+import { sessionMetaSelectors } from './selectors/meta';
 
 const n = setNamespace('session');
 
@@ -53,6 +54,7 @@ export interface SessionAction {
   ) => Promise<string>;
   duplicateSession: (id: string) => Promise<void>;
   updateSessionGroupId: (sessionId: string, groupId: string) => Promise<void>;
+  updateSessionMeta: (meta: Partial<MetaData>) => void;
 
   /**
    * Pins or unpins a session.
@@ -61,7 +63,7 @@ export interface SessionAction {
   /**
    * re-fetch the data
    */
-  refreshSessions: (params?: SWRRefreshParams<ChatSessionList>) => Promise<void>;
+  refreshSessions: () => Promise<void>;
   /**
    * remove session
    * @param id - sessionId
@@ -106,7 +108,7 @@ export const createSessionSlice: StateCreator<
 
     // merge the defaultAgent in settings
     const defaultAgent = merge(
-      initLobeSession,
+      DEFAULT_AGENT_LOBE_SESSION,
       settingsSelectors.defaultAgent(useGlobalStore.getState()),
     );
 
@@ -125,7 +127,7 @@ export const createSessionSlice: StateCreator<
     const session = sessionSelectors.getSessionById(id)(get());
 
     if (!session) return;
-    const title = agentSelectors.getTitle(session.meta);
+    const title = sessionMetaSelectors.getTitle(session.meta);
 
     const newTitle = t('duplicateSession.title', { ns: 'chat', title: title });
 
@@ -157,10 +159,6 @@ export const createSessionSlice: StateCreator<
     await get().internal_updateSession(id, { pinned });
   },
 
-  refreshSessions: async () => {
-    await mutate(FETCH_SESSIONS_KEY);
-  },
-
   removeSession: async (sessionId) => {
     await sessionService.removeSession(sessionId);
     await get().refreshSessions();
@@ -175,16 +173,25 @@ export const createSessionSlice: StateCreator<
     await get().internal_updateSession(sessionId, { group });
   },
 
+  updateSessionMeta: async (meta) => {
+    const session = sessionSelectors.currentSession(get());
+    if (!session) return;
+
+    const { activeId, refreshSessions } = get();
+
+    await sessionService.updateSession(activeId, { meta });
+    await refreshSessions();
+  },
+
   useFetchSessions: () =>
     useClientDataSWR<ChatSessionList>(FETCH_SESSIONS_KEY, sessionService.getGroupedSessions, {
       onSuccess: (data) => {
-        // 由于 https://github.com/lobehub/lobe-chat/pull/541 的关系
-        // 只有触发了 refreshSessions 才会更新 sessions，进而触发页面 rerender
-        // 因此这里不能补充 equal 判断，否则会导致页面不更新
-        // if (get().isSessionsFirstFetchFinished && isEqual(get().sessions, data)) return;
-
-        // TODO：后续的根本解法应该是解除 inbox 和 session 的数据耦合
-        // 避免互相依赖的情况出现
+        if (
+          get().isSessionsFirstFetchFinished &&
+          isEqual(get().sessions, data.sessions) &&
+          isEqual(get().sessionGroups, data.sessionGroups)
+        )
+          return;
 
         get().internal_processSessions(
           data.sessions,
@@ -239,4 +246,7 @@ export const createSessionSlice: StateCreator<
       n('processSessions'),
     );
   },
+  refreshSessions: async () => {
+    await mutate(FETCH_SESSIONS_KEY);
+  },
 });

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

@@ -1,13 +1,12 @@
+import { DEFAULT_AGENT_LOBE_SESSION } from '@/const/session';
 import { LobeAgentSession, LobeSessions } from '@/types/session';
 
-import { initLobeSession } from './initialState';
-
 export const getSessionPinned = (session: LobeAgentSession) => session.pinned;
 
 const getSessionById = (id: string, sessions: LobeSessions): LobeAgentSession => {
   const session = sessions.find((s) => s.id === id);
 
-  if (!session) return initLobeSession;
+  if (!session) return DEFAULT_AGENT_LOBE_SESSION;
 
   return session;
 };

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

@@ -1,20 +1,4 @@
-import { DEFAULT_AGENT_META } from '@/const/meta';
-import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
-import {
-  CustomSessionGroup,
-  LobeAgentSession,
-  LobeSessionGroups,
-  LobeSessionType,
-} from '@/types/session';
-
-export const initLobeSession: LobeAgentSession = {
-  config: DEFAULT_AGENT_CONFIG,
-  createdAt: Date.now(),
-  id: '',
-  meta: DEFAULT_AGENT_META,
-  type: LobeSessionType.Agent,
-  updatedAt: Date.now(),
-};
+import { CustomSessionGroup, LobeAgentSession, LobeSessionGroups } from '@/types/session';
 
 export interface SessionState {
   /**

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

@@ -1 +1,2 @@
 export * from './list';
+export * from './meta';

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

@@ -1,7 +1,7 @@
+import { DEFAULT_AGENT_LOBE_SESSION } from '@/const/session';
 import type { SessionStore } from '@/store/session';
 import { LobeAgentSession, LobeSessionType } from '@/types/session';
 
-import { initLobeSession } from '../initialState';
 import { sessionSelectors } from './list';
 
 describe('currentSession', () => {
@@ -64,7 +64,9 @@ describe('currentSessionSafe', () => {
   } as unknown as SessionStore;
 
   it('should return initLobeSession when currentSession(s) returns undefined', () => {
-    expect(sessionSelectors.currentSessionSafe({ sessions: {} } as any)).toEqual(initLobeSession);
+    expect(sessionSelectors.currentSessionSafe({ sessions: {} } as any)).toEqual(
+      DEFAULT_AGENT_LOBE_SESSION,
+    );
   });
 
   it('should return the result of currentSession(s) when it returns a non-undefined value', () => {
@@ -102,7 +104,7 @@ describe('getSessionById', () => {
   });
 
   it('should return initLobeSession when the session with the specified id does not exist', () => {
-    expect(sessionSelectors.getSessionById('3')(s)).toEqual(initLobeSession);
+    expect(sessionSelectors.getSessionById('3')(s)).toEqual(DEFAULT_AGENT_LOBE_SESSION);
   });
 });
 

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

@@ -1,10 +1,9 @@
-import { INBOX_SESSION_ID } from '@/const/session';
+import { DEFAULT_AGENT_LOBE_SESSION, INBOX_SESSION_ID } from '@/const/session';
 import { sessionHelpers } from '@/store/session/slices/session/helpers';
 import { MetaData } from '@/types/meta';
 import { CustomSessionGroup, LobeAgentSession, LobeSessions } from '@/types/session';
 
 import { SessionStore } from '../../../store';
-import { initLobeSession } from '../initialState';
 
 const defaultSessions = (s: SessionStore): LobeSessions => s.defaultSessions;
 const pinnedSessions = (s: SessionStore): LobeSessions => s.pinnedSessions;
@@ -33,7 +32,7 @@ const currentSession = (s: SessionStore): LobeAgentSession | undefined => {
 };
 
 const currentSessionSafe = (s: SessionStore): LobeAgentSession => {
-  return currentSession(s) || initLobeSession;
+  return currentSession(s) || DEFAULT_AGENT_LOBE_SESSION;
 };
 
 const hasCustomAgents = (s: SessionStore) => defaultSessions(s).length > 0;

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

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest';
+
+import { DEFAULT_AVATAR } from '@/const/meta';
+import { DEFAULT_AGENT_CONFIG, DEFAUTT_AGENT_TTS_CONFIG } from '@/const/settings';
+import { SessionStore } from '@/store/session';
+import { MetaData } from '@/types/meta';
+import { LobeAgentSession, LobeSessionType } from '@/types/session';
+
+import { sessionMetaSelectors } from './meta';
+
+vi.mock('i18next', () => ({
+  t: vi.fn((key) => key), // Simplified mock return value
+}));
+
+const mockSessionStore = {
+  activeId: '1',
+  sessions: [
+    {
+      id: '1',
+      config: DEFAULT_AGENT_CONFIG,
+      meta: {
+        title: 'title1',
+        description: 'description1',
+      },
+      type: LobeSessionType.Agent,
+    } as LobeAgentSession,
+    {
+      id: '2',
+      meta: {
+        title: 'title2',
+        description: 'description2',
+      },
+      config: DEFAULT_AGENT_CONFIG,
+      type: LobeSessionType.Agent,
+    } as LobeAgentSession,
+  ],
+} as unknown as SessionStore;
+
+describe('sessionMetaSelectors', () => {
+  describe('currentAgentMeta', () => {
+    it('should return the merged default and session-specific meta data', () => {
+      const meta = sessionMetaSelectors.currentAgentMeta(mockSessionStore);
+      expect(meta).toEqual(expect.objectContaining(mockSessionStore.sessions[0].meta));
+    });
+
+    it('should return inbox defaults if it is an inbox session', () => {
+      // Assume sessionSelectors.isInboxSession() is mocked to return true for this test
+      const meta = sessionMetaSelectors.currentAgentMeta(mockSessionStore);
+      expect(meta.avatar).toBe(DEFAULT_AVATAR);
+    });
+  });
+
+  describe('currentAgentTitle', () => {
+    it('should return the title from the session meta data', () => {
+      const title = sessionMetaSelectors.currentAgentTitle(mockSessionStore);
+      expect(title).toBe(mockSessionStore.sessions[0].meta.title);
+    });
+  });
+
+  describe('currentAgentDescription', () => {
+    it('should return the description from the session meta data', () => {
+      const description = sessionMetaSelectors.currentAgentDescription(mockSessionStore);
+      expect(description).toBe(mockSessionStore.sessions[0].meta.description);
+    });
+  });
+
+  describe('getAvatar', () => {
+    it('should return the avatar from the meta data', () => {
+      const meta: MetaData = { avatar: 'custom-avatar.png' };
+      const avatar = sessionMetaSelectors.getAvatar(meta);
+      expect(avatar).toBe(meta.avatar);
+    });
+
+    it('should return the default avatar if none is defined in the meta data', () => {
+      const meta: MetaData = {};
+      const avatar = sessionMetaSelectors.getAvatar(meta);
+      expect(avatar).toBe(DEFAULT_AVATAR);
+    });
+  });
+
+  describe('getTitle', () => {
+    it('should return the title from the meta data', () => {
+      const meta: MetaData = { title: 'Custom Title' };
+      const title = sessionMetaSelectors.getTitle(meta);
+      expect(title).toBe(meta.title);
+    });
+
+    it('should return the default title if none is defined in the meta data', () => {
+      const meta: MetaData = {};
+      const title = sessionMetaSelectors.getTitle(meta);
+      expect(title).toBe('defaultSession'); // Assuming translation returns this key
+    });
+  });
+
+  describe('getDescription', () => {
+    it('should return the description from the meta data', () => {
+      const meta: MetaData = { description: 'Custom Description' };
+      const description = sessionMetaSelectors.getDescription(meta);
+      expect(description).toBe(meta.description);
+    });
+
+    it('should return the default description if none is defined in the meta data', () => {
+      const meta: MetaData = {};
+      const description = sessionMetaSelectors.getDescription(meta);
+      expect(description).toBe('noDescription'); // Assuming translation returns this key
+    });
+  });
+});