@lobehub/chat 0.149.4 → 0.149.5

package/src/store/{session/slices/agent → agent/slices/chat}/action.test.ts

@@ -3,14 +3,14 @@ import * as immer from 'immer';
 import { describe, expect, it, vi } from 'vitest';
 
 import { sessionService } from '@/services/session';
+import { useAgentStore } from '@/store/agent';
+import { agentSelectors } from '@/store/agent/selectors';
 import { useGlobalStore } from '@/store/global';
-import { useSessionStore } from '@/store/session';
-import { agentSelectors, sessionSelectors } from '@/store/session/selectors';
 
 describe('AgentSlice', () => {
   describe('removePlugin', () => {
     it('should call togglePlugin with the provided id and false', async () => {
-      const { result } = renderHook(() => useSessionStore());
+      const { result } = renderHook(() => useAgentStore());
       const pluginId = 'plugin-id';
       const togglePluginMock = vi.spyOn(result.current, 'togglePlugin');
 
@@ -25,7 +25,7 @@ describe('AgentSlice', () => {
 
   describe('togglePlugin', () => {
     it('should add plugin id to plugins array if not present and open is true or undefined', async () => {
-      const { result } = renderHook(() => useSessionStore());
+      const { result } = renderHook(() => useAgentStore());
       const pluginId = 'plugin-id';
       const updateAgentConfigMock = vi.spyOn(result.current, 'updateAgentConfig');
 
@@ -43,7 +43,7 @@ describe('AgentSlice', () => {
     });
 
     it('should remove plugin id from plugins array if present and open is false', async () => {
-      const { result } = renderHook(() => useSessionStore());
+      const { result } = renderHook(() => useAgentStore());
       const pluginId = 'plugin-id';
       const updateAgentConfigMock = vi.spyOn(result.current, 'updateAgentConfig');
 
@@ -61,7 +61,7 @@ describe('AgentSlice', () => {
     });
 
     it('should not modify plugins array if plugin id is not present and open is false', async () => {
-      const { result } = renderHook(() => useSessionStore());
+      const { result } = renderHook(() => useAgentStore());
       const pluginId = 'plugin-id';
       const updateAgentConfigMock = vi.spyOn(result.current, 'updateAgentConfig');
 
@@ -79,49 +79,53 @@ describe('AgentSlice', () => {
 
   describe('updateAgentConfig', () => {
     it('should update global config if current session is inbox session', async () => {
-      const { result } = renderHook(() => useSessionStore());
+      const { result } = renderHook(() => useAgentStore());
       const config = { model: 'gpt-3.5-turbo' };
-      const updateDefaultAgentMock = vi.spyOn(useGlobalStore.getState(), 'updateDefaultAgent');
-
-      // 模拟当前会话是收件箱会话
-      vi.spyOn(sessionSelectors, 'isInboxSession').mockReturnValue(true);
+      const updateSessionConfigMock = vi.spyOn(sessionService, 'updateSessionConfig');
+      const refreshMock = vi.spyOn(result.current, 'internal_refreshAgentConfig');
 
       await act(async () => {
         await result.current.updateAgentConfig(config);
       });
 
-      expect(updateDefaultAgentMock).toHaveBeenCalledWith({ config });
-      updateDefaultAgentMock.mockRestore();
+      expect(updateSessionConfigMock).toHaveBeenCalledWith('inbox', config);
+      expect(refreshMock).toHaveBeenCalled();
+      updateSessionConfigMock.mockRestore();
+      refreshMock.mockRestore();
     });
 
     it('should update session config if current session is not inbox session', async () => {
-      const { result } = renderHook(() => useSessionStore());
+      const { result } = renderHook(() => useAgentStore());
       const config = { model: 'gpt-3.5-turbo' };
       const updateSessionConfigMock = vi.spyOn(sessionService, 'updateSessionConfig');
-      const refreshSessionsMock = vi.spyOn(result.current, 'refreshSessions');
+      const refreshMock = vi.spyOn(result.current, 'internal_refreshAgentConfig');
 
       // 模拟当前会话不是收件箱会话
-      vi.spyOn(sessionSelectors, 'isInboxSession').mockReturnValue(false);
-      vi.spyOn(sessionSelectors, 'currentSession').mockReturnValue({ id: 'session-id' } as any);
-      vi.spyOn(result.current, 'activeId', 'get').mockReturnValue('session-id');
+      act(() => {
+        useAgentStore.setState({
+          activeId: 'session-id',
+        });
+      });
 
       await act(async () => {
         await result.current.updateAgentConfig(config);
       });
 
       expect(updateSessionConfigMock).toHaveBeenCalledWith('session-id', config);
-      expect(refreshSessionsMock).toHaveBeenCalled();
+      expect(refreshMock).toHaveBeenCalled();
       updateSessionConfigMock.mockRestore();
-      refreshSessionsMock.mockRestore();
+      refreshMock.mockRestore();
     });
 
     it('should not update config if there is no current session', async () => {
-      const { result } = renderHook(() => useSessionStore());
+      const { result } = renderHook(() => useAgentStore());
       const config = { model: 'gpt-3.5-turbo' };
       const updateSessionConfigMock = vi.spyOn(sessionService, 'updateSessionConfig');
 
       // 模拟没有当前会话
-      vi.spyOn(sessionSelectors, 'currentSession').mockReturnValue(null as any);
+      act(() => {
+        useAgentStore.setState({ activeId: null as any });
+      });
 
       await act(async () => {
         await result.current.updateAgentConfig(config);
@@ -131,45 +135,4 @@ describe('AgentSlice', () => {
       updateSessionConfigMock.mockRestore();
     });
   });
-
-  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.updateAgentMeta(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.updateAgentMeta(meta);
-      });
-
-      expect(updateSessionMock).toHaveBeenCalledWith('session-id', { meta });
-      expect(refreshSessionsMock).toHaveBeenCalled();
-      updateSessionMock.mockRestore();
-      refreshSessionsMock.mockRestore();
-    });
-  });
 });

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

@@ -0,0 +1,107 @@
+import isEqual from 'fast-deep-equal';
+import { produce } from 'immer';
+import { SWRResponse, mutate } from 'swr';
+import { DeepPartial } from 'utility-types';
+import { StateCreator } from 'zustand/vanilla';
+
+import { useClientDataSWR } from '@/libs/swr';
+import { sessionService } from '@/services/session';
+import { useSessionStore } from '@/store/session';
+import { LobeAgentConfig } from '@/types/agent';
+import { merge } from '@/utils/merge';
+
+import { AgentStore } from '../../store';
+import { agentSelectors } from './selectors';
+
+/**
+ * 助手接口
+ */
+export interface AgentChatAction {
+  removePlugin: (id: string) => void;
+  togglePlugin: (id: string, open?: boolean) => Promise<void>;
+  updateAgentConfig: (config: Partial<LobeAgentConfig>) => Promise<void>;
+
+  useFetchAgentConfig: (id: string) => SWRResponse<LobeAgentConfig>;
+
+  /* eslint-disable typescript-sort-keys/interface */
+
+  internal_updateAgentConfig: (id: string, data: DeepPartial<LobeAgentConfig>) => Promise<void>;
+  internal_refreshAgentConfig: (id: string) => Promise<void>;
+  /* eslint-enable */
+}
+
+const FETCH_AGENT_CONFIG_KEY = 'FETCH_AGENT_CONFIG';
+
+export const createChatSlice: StateCreator<
+  AgentStore,
+  [['zustand/devtools', never]],
+  [],
+  AgentChatAction
+> = (set, get) => ({
+  removePlugin: async (id) => {
+    await get().togglePlugin(id, false);
+  },
+
+  togglePlugin: async (id, open) => {
+    const originConfig = agentSelectors.currentAgentConfig(get());
+
+    const config = produce(originConfig, (draft) => {
+      draft.plugins = produce(draft.plugins || [], (plugins) => {
+        const index = plugins.indexOf(id);
+        const shouldOpen = open !== undefined ? open : index === -1;
+
+        if (shouldOpen) {
+          // 如果 open 为 true 或者 id 不存在于 plugins 中，则添加它
+          if (index === -1) {
+            plugins.push(id);
+          }
+        } else {
+          // 如果 open 为 false 或者 id 存在于 plugins 中，则移除它
+          if (index !== -1) {
+            plugins.splice(index, 1);
+          }
+        }
+      });
+    });
+
+    await get().updateAgentConfig(config);
+  },
+  updateAgentConfig: async (config) => {
+    const { activeId } = get();
+
+    if (!activeId) return;
+
+    await get().internal_updateAgentConfig(activeId, config);
+  },
+
+  useFetchAgentConfig: (sessionId) =>
+    useClientDataSWR<LobeAgentConfig>(
+      [FETCH_AGENT_CONFIG_KEY, sessionId],
+      ([, id]: string[]) => sessionService.getSessionConfig(id),
+      {
+        onSuccess: (data) => {
+          if (get().isAgentConfigInit && isEqual(get().agentConfig, data)) return;
+
+          set({ agentConfig: data, isAgentConfigInit: true }, false, 'fetchAgentConfig');
+        },
+      },
+    ),
+
+  /* eslint-disable sort-keys-fix/sort-keys-fix */
+
+  internal_updateAgentConfig: async (id, data) => {
+    const prevModel = agentSelectors.currentAgentModel(get());
+    // optimistic update at frontend
+    set({ agentConfig: merge(get().agentConfig, data) }, false, 'optimistic_updateAgentConfig');
+
+    await sessionService.updateSessionConfig(id, data);
+    await get().internal_refreshAgentConfig(id);
+
+    // refresh sessions to update the agent config if the model has changed
+    if (prevModel !== data.model) await useSessionStore.getState().refreshSessions();
+  },
+
+  internal_refreshAgentConfig: async (id) => {
+    await mutate([FETCH_AGENT_CONFIG_KEY, id]);
+  },
+});

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

@@ -0,0 +1,14 @@
+import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
+import { LobeAgentConfig } from '@/types/agent';
+
+export interface AgentState {
+  activeId: string;
+  agentConfig: LobeAgentConfig;
+  isAgentConfigInit: boolean;
+}
+
+export const initialSessionState: AgentState = {
+  activeId: 'inbox',
+  agentConfig: DEFAULT_AGENT_CONFIG,
+  isAgentConfigInit: false,
+};

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

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+
+import { DEFAULT_AGENT_CONFIG, DEFAUTT_AGENT_TTS_CONFIG } from '@/const/settings';
+import { AgentStore } from '@/store/agent';
+
+import { agentSelectors } from './selectors';
+
+vi.mock('i18next', () => ({
+  t: vi.fn((key) => key), // Simplified mock return value
+}));
+
+const mockSessionStore = {
+  activeId: '1',
+  agentConfig: DEFAULT_AGENT_CONFIG,
+} as AgentStore;
+
+describe('agentSelectors', () => {
+  describe('currentAgentConfig', () => {
+    it('should return the merged default and session-specific agent config', () => {
+      const config = agentSelectors.currentAgentConfig(mockSessionStore);
+      expect(config).toEqual(expect.objectContaining(mockSessionStore.agentConfig));
+    });
+  });
+
+  describe('currentAgentModel', () => {
+    it('should return the model from the agent config', () => {
+      const model = agentSelectors.currentAgentModel(mockSessionStore);
+      expect(model).toBe(mockSessionStore.agentConfig.model);
+    });
+  });
+
+  describe('hasSystemRole', () => {
+    it('should return true if the system role is defined in the agent config', () => {
+      const hasRole = agentSelectors.hasSystemRole(mockSessionStore);
+      expect(hasRole).toBe(false);
+    });
+
+    it('should return false if the system role is not defined in the agent config', () => {
+      const modifiedSessionStore = {
+        ...mockSessionStore,
+        agentConfig: {
+          ...mockSessionStore.agentConfig,
+          systemRole: 'test',
+        },
+      };
+      const hasRole = agentSelectors.hasSystemRole(modifiedSessionStore);
+      expect(hasRole).toBe(true);
+    });
+  });
+
+  describe('currentAgentTTS', () => {
+    it('should return the TTS config from the agent config', () => {
+      const ttsConfig = agentSelectors.currentAgentTTS(mockSessionStore);
+      expect(ttsConfig).toEqual(mockSessionStore.agentConfig.tts);
+    });
+
+    it('should return the default TTS config if none is defined in the agent config', () => {
+      const modifiedSessionStore = {
+        ...mockSessionStore,
+        sessions: [
+          {
+            ...mockSessionStore.agentConfig,
+            config: {
+              ...mockSessionStore.agentConfig,
+              tts: DEFAUTT_AGENT_TTS_CONFIG,
+            },
+          },
+        ],
+      };
+      const ttsConfig = agentSelectors.currentAgentTTS(modifiedSessionStore);
+      expect(ttsConfig).toEqual(DEFAUTT_AGENT_TTS_CONFIG);
+    });
+  });
+
+  describe('currentAgentTTSVoice', () => {
+    it('should return the appropriate TTS voice based on the service and language', () => {
+      const lang = 'en';
+      const ttsVoice = agentSelectors.currentAgentTTSVoice(lang)(mockSessionStore);
+      expect(ttsVoice).toBe(mockSessionStore.agentConfig.tts.voice.openai);
+    });
+  });
+});

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';