@lobehub/chat 0.120.6 → 0.121.0

package/src/services/config.ts

@@ -4,10 +4,10 @@ import { topicService } from '@/services/topic';
 import { useGlobalStore } from '@/store/global';
 import { settingsSelectors } from '@/store/global/selectors';
 import { useSessionStore } from '@/store/session';
-import { sessionExportSelectors, sessionSelectors } from '@/store/session/selectors';
+import { sessionSelectors } from '@/store/session/selectors';
 import { ConfigFile } from '@/types/exportConfig';
 import { ChatMessage } from '@/types/message';
-import { LobeSessions } from '@/types/session';
+import { LobeSessions, SessionGroupItem } from '@/types/session';
 import { GlobalSettings } from '@/types/settings';
 import { ChatTopic } from '@/types/topic';
 import { createConfigFile, exportConfigFile } from '@/utils/config';
@@ -19,6 +19,7 @@ export interface ImportResult {
 }
 export interface ImportResults {
   messages?: ImportResult;
+  sessionGroups?: ImportResult;
   sessions: ImportResult;
   topics?: ImportResult;
 }
@@ -40,6 +41,9 @@ class ConfigService {
   importTopics = async (topics: ChatTopic[]) => {
     return topicService.batchCreateTopics(topics);
   };
+  importSessionGroups = async (sessionGroups: SessionGroupItem[]) => {
+    return sessionService.batchCreateSessionGroups(sessionGroups);
+  };
 
   importConfigState = async (config: ConfigFile): Promise<ImportResults | undefined> => {
     switch (config.exportType) {
@@ -50,8 +54,11 @@ class ConfigService {
       }
 
       case 'agents': {
+        const sessionGroups = await this.importSessionGroups(config.state.sessionGroups);
+
         const data = await this.importSessions(config.state.sessions);
         return {
+          sessionGroups: this.mapImportResult(sessionGroups),
           sessions: this.mapImportResult(data),
         };
       }
@@ -59,6 +66,8 @@ class ConfigService {
       case 'all': {
         await this.importSettings(config.state.settings);
 
+        const sessionGroups = await this.importSessionGroups(config.state.sessionGroups);
+
         const [sessions, messages, topics] = await Promise.all([
           this.importSessions(config.state.sessions),
           this.importMessages(config.state.messages),
@@ -67,12 +76,15 @@ class ConfigService {
 
         return {
           messages: this.mapImportResult(messages),
+          sessionGroups: this.mapImportResult(sessionGroups),
           sessions: this.mapImportResult(sessions),
           topics: this.mapImportResult(topics),
         };
       }
 
       case 'sessions': {
+        const sessionGroups = await this.importSessionGroups(config.state.sessionGroups);
+
         const [sessions, messages, topics] = await Promise.all([
           this.importSessions(config.state.sessions),
           this.importMessages(config.state.messages),
@@ -81,6 +93,7 @@ class ConfigService {
 
         return {
           messages: this.mapImportResult(messages),
+          sessionGroups: this.mapImportResult(sessionGroups),
           sessions: this.mapImportResult(sessions),
           topics: this.mapImportResult(topics),
         };
@@ -93,8 +106,9 @@ class ConfigService {
    */
   exportAgents = async () => {
     const agents = await sessionService.getAllAgents();
+    const sessionGroups = await sessionService.getSessionGroups();
 
-    const config = createConfigFile('agents', { sessions: agents });
+    const config = createConfigFile('agents', { sessionGroups, sessions: agents });
 
     exportConfigFile(config, 'agents');
   };
@@ -104,10 +118,11 @@ class ConfigService {
    */
   exportSessions = async () => {
     const sessions = await sessionService.getSessions();
+    const sessionGroups = await sessionService.getSessionGroups();
     const messages = await messageService.getAllMessages();
     const topics = await topicService.getAllTopics();
 
-    const config = createConfigFile('sessions', { messages, sessions, topics });
+    const config = createConfigFile('sessions', { messages, sessionGroups, sessions, topics });
 
     exportConfigFile(config, 'sessions');
   };
@@ -153,7 +168,7 @@ class ConfigService {
     const agent = this.getAgent(id);
     if (!agent) return;
 
-    const config = createConfigFile('agents', { sessions: [agent] });
+    const config = createConfigFile('agents', { sessionGroups: [], sessions: [agent] });
 
     exportConfigFile(config, agent.meta?.title || 'agent');
   };
@@ -174,11 +189,12 @@ class ConfigService {
    */
   exportAll = async () => {
     const sessions = await sessionService.getSessions();
+    const sessionGroups = await sessionService.getSessionGroups();
     const messages = await messageService.getAllMessages();
     const topics = await topicService.getAllTopics();
     const settings = this.getSettings();
 
-    const config = createConfigFile('all', { messages, sessions, settings, topics });
+    const config = createConfigFile('all', { messages, sessionGroups, sessions, settings, topics });
 
     exportConfigFile(config, 'config');
   };
@@ -189,7 +205,7 @@ class ConfigService {
     sessionSelectors.getSessionById(id)(useSessionStore.getState());
 
   private getAgent = (id: string) =>
-    sessionExportSelectors.getExportAgent(id)(useSessionStore.getState());
+    sessionSelectors.getSessionById(id)(useSessionStore.getState());
 
   private mapImportResult = (input: {
     added: number;

package/src/services/session.ts

@@ -1,9 +1,18 @@
 import { DeepPartial } from 'utility-types';
 
 import { SessionModel } from '@/database/models/session';
+import { SessionGroupModel } from '@/database/models/sessionGroup';
 import { LobeAgentConfig } from '@/types/agent';
 import { MetaData } from '@/types/meta';
-import { LobeAgentSession, LobeSessionType, LobeSessions, SessionGroupKey } from '@/types/session';
+import {
+  ChatSessionList,
+  LobeAgentSession,
+  LobeSessionType,
+  LobeSessions,
+  SessionGroupId,
+  SessionGroupItem,
+  SessionGroups,
+} from '@/types/session';
 
 class SessionService {
   async createNewSession(
@@ -21,26 +30,40 @@ class SessionService {
     return SessionModel.batchCreate(importSessions);
   }
 
+  async duplicateSession(id: string, newTitle: string): Promise<string | undefined> {
+    const res = await SessionModel.duplicate(id, newTitle);
+
+    if (res) return res?.id;
+  }
+
   async getSessions(): Promise<LobeSessions> {
     return SessionModel.query();
   }
 
+  async getSessionsWithGroup(): Promise<ChatSessionList> {
+    return SessionModel.queryWithGroups();
+  }
+
   async getAllAgents(): Promise<LobeSessions> {
     // TODO: add a filter to get only agents
     return await SessionModel.query();
   }
 
-  async removeSession(id: string) {
-    return SessionModel.delete(id);
+  async hasSessions() {
+    const isEmpty = await SessionModel.isEmpty();
+    return !isEmpty;
   }
 
-  async removeAllSessions() {
-    return SessionModel.clearTable();
+  async searchSessions(keyword: string) {
+    return SessionModel.queryByKeyword(keyword);
   }
 
-  async updateSessionGroup(id: string, group: SessionGroupKey) {
+  async updateSessionGroupId(id: string, group: SessionGroupId) {
     return SessionModel.update(id, { group });
   }
+  async updateSessionPinned(id: string, pinned: boolean) {
+    return SessionModel.updatePinned(id, pinned);
+  }
 
   async updateSessionMeta(activeId: string, meta: Partial<MetaData>) {
     return SessionModel.update(activeId, { meta });
@@ -50,19 +73,49 @@ class SessionService {
     return SessionModel.updateConfig(activeId, config);
   }
 
-  async hasSessions() {
-    const isEmpty = await SessionModel.isEmpty();
-    return !isEmpty;
+  async removeSession(id: string) {
+    return SessionModel.delete(id);
   }
 
-  async searchSessions(keyword: string) {
-    return SessionModel.queryByKeyword(keyword);
+  async removeAllSessions() {
+    return SessionModel.clearTable();
   }
 
-  async duplicateSession(id: string, newTitle: string): Promise<string | undefined> {
-    const res = await SessionModel.duplicate(id, newTitle);
+  // ************************************** //
+  // ***********  SessionGroup  *********** //
+  // ************************************** //
 
-    if (res) return res?.id;
+  async createSessionGroup(name: string, sort?: number) {
+    const item = await SessionGroupModel.create(name, sort);
+    if (!item) {
+      throw new Error('session group create Error');
+    }
+
+    return item.id;
+  }
+
+  async batchCreateSessionGroups(groups: SessionGroups) {
+    return SessionGroupModel.batchCreate(groups);
+  }
+
+  async removeSessionGroup(id: string, removeChildren?: boolean) {
+    return await SessionGroupModel.delete(id, removeChildren);
+  }
+
+  async updateSessionGroup(id: string, data: Partial<SessionGroupItem>) {
+    return SessionGroupModel.update(id, data);
+  }
+
+  async updateSessionGroupOrder(sortMap: { id: string; sort: number }[]) {
+    return SessionGroupModel.updateOrder(sortMap);
+  }
+
+  async getSessionGroups(): Promise<SessionGroupItem[]> {
+    return SessionGroupModel.query();
+  }
+
+  async clearSessionGroups() {
+    return SessionGroupModel.clear();
   }
 }
 

package/src/store/global/slices/common/action.test.ts

@@ -0,0 +1,130 @@
+import { act, renderHook } from '@testing-library/react';
+import { router } from 'next/client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { globalService } from '@/services/global';
+import { useGlobalStore } from '@/store/global';
+import { type Guide, SidebarTabKey } from '@/store/global/slices/common/initialState';
+
+// Mock globalService
+vi.mock('@/services/global', () => ({
+  globalService: {
+    getLatestVersion: vi.fn(),
+    getGlobalConfig: vi.fn(),
+  },
+}));
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('createCommonSlice', () => {
+  describe('switchBackToChat', () => {
+    it('should switch back to chat', () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const sessionId = 'session-id';
+      const router = { push: vi.fn() } as any;
+
+      act(() => {
+        useGlobalStore.setState({ router });
+        result.current.switchBackToChat(sessionId);
+      });
+
+      expect(router.push).toHaveBeenCalledWith('/chat?session=session-id');
+    });
+  });
+
+  describe('switchSideBar', () => {
+    it('should switch sidebar', () => {
+      const { result } = renderHook(() => useGlobalStore());
+
+      act(() => {
+        result.current.switchSideBar(SidebarTabKey.Market);
+      });
+
+      expect(result.current.sidebarKey).toEqual(SidebarTabKey.Market);
+    });
+  });
+
+  describe('toggleChatSideBar', () => {
+    it('should toggle chat sidebar', () => {
+      const { result } = renderHook(() => useGlobalStore());
+
+      act(() => {
+        useGlobalStore.getState().updatePreference({ showChatSideBar: false });
+        result.current.toggleChatSideBar();
+      });
+
+      expect(result.current.preference.showChatSideBar).toBe(true);
+    });
+
+    // Add more tests for other actions in createCommonSlice
+  });
+
+  describe('toggleExpandSessionGroup', () => {
+    it('should toggle expand session group', () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const groupId = 'group-id';
+
+      act(() => {
+        result.current.toggleExpandSessionGroup(groupId, true);
+      });
+
+      expect(result.current.preference.expandSessionGroupKeys).toContain(groupId);
+    });
+  });
+
+  describe('toggleMobileTopic', () => {
+    it('should toggle mobile topic', () => {
+      const { result } = renderHook(() => useGlobalStore());
+
+      act(() => {
+        result.current.toggleMobileTopic();
+      });
+
+      expect(result.current.preference.mobileShowTopic).toBe(true);
+    });
+  });
+
+  describe('toggleSystemRole', () => {
+    it('should toggle system role', () => {
+      const { result } = renderHook(() => useGlobalStore());
+
+      act(() => {
+        result.current.toggleSystemRole(true);
+      });
+
+      expect(result.current.preference.showSystemRole).toBe(true);
+    });
+  });
+
+  describe('updateGuideState', () => {
+    it('should update guide state', () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const guide: Guide = { topic: true };
+
+      act(() => {
+        result.current.updateGuideState(guide);
+      });
+
+      expect(result.current.preference.guide).toEqual(guide);
+    });
+  });
+
+  describe('updatePreference', () => {
+    it('should update preference', () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const preference = { inputHeight: 200 };
+
+      act(() => {
+        result.current.updatePreference(preference);
+      });
+
+      expect(result.current.preference.inputHeight).toEqual(200);
+    });
+  });
+});

package/src/store/global/slices/common/action.ts

@@ -27,6 +27,7 @@ export interface CommonAction {
    */
   switchSideBar: (key: SidebarTabKey) => void;
   toggleChatSideBar: (visible?: boolean) => void;
+  toggleExpandSessionGroup: (id: string, expand: boolean) => void;
   toggleMobileTopic: (visible?: boolean) => void;
   toggleSystemRole: (visible?: boolean) => void;
   updateGuideState: (guide: Partial<Guide>) => void;
@@ -53,6 +54,19 @@ export const createCommonSlice: StateCreator<
 
     get().updatePreference({ showChatSideBar }, n('toggleAgentPanel', newValue) as string);
   },
+  toggleExpandSessionGroup: (id, expand) => {
+    const { preference } = get();
+    const nextExpandSessionGroup = produce(preference.expandSessionGroupKeys, (draft) => {
+      if (expand) {
+        if (draft.includes(id)) return;
+        draft.push(id);
+      } else {
+        const index = draft.indexOf(id);
+        if (index !== -1) draft.splice(index, 1);
+      }
+    });
+    get().updatePreference({ expandSessionGroupKeys: nextExpandSessionGroup });
+  },
   toggleMobileTopic: (newValue) => {
     const mobileShowTopic =
       typeof newValue === 'boolean' ? newValue : !get().preference.mobileShowTopic;

package/src/store/global/slices/common/initialState.ts

@@ -1,5 +1,7 @@
 import { AppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime';
 
+import { SessionDefaultGroup, SessionGroupId } from '@/types/session';
+
 export enum SidebarTabKey {
   Chat = 'chat',
   Market = 'market',
@@ -19,11 +21,13 @@ export interface Guide {
 }
 
 export interface GlobalPreference {
+  // which sessionGroup should expand
+  expandSessionGroupKeys: SessionGroupId[];
   guide?: Guide;
   inputHeight: number;
   mobileShowTopic?: boolean;
-  sessionGroupKeys: string[];
   sessionsWidth: number;
+
   showChatSideBar?: boolean;
   showSessionPanel?: boolean;
   showSystemRole?: boolean;
@@ -50,10 +54,10 @@ export interface GlobalCommonState {
 export const initialCommonState: GlobalCommonState = {
   isMobile: false,
   preference: {
+    expandSessionGroupKeys: [SessionDefaultGroup.Pinned, SessionDefaultGroup.Default],
     guide: {},
     inputHeight: 200,
     mobileShowTopic: false,
-    sessionGroupKeys: ['pinned', 'sessionList'],
     sessionsWidth: 320,
     showChatSideBar: true,
     showSessionPanel: true,

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

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

package/src/store/global/slices/settings/__snapshots__/selectors.test.ts.snap

@@ -161,3 +161,86 @@ exports[`settingsSelectors > currentSettings > should merge DEFAULT_SETTINGS and
   },
 }
 `;
+
+exports[`settingsSelectors > currentTTS > should merge DEFAULT_TTS_CONFIG and s.settings.tts correctly 1`] = `
+{
+  "openAI": {
+    "sttModel": "whisper-2",
+    "ttsModel": "tts-1",
+  },
+  "sttAutoStop": false,
+  "sttServer": "openai",
+}
+`;
+
+exports[`settingsSelectors > dalleConfig > should return the dalle configuration 1`] = `
+{
+  "apiKey": "dalle-api-key",
+  "autoGenerate": true,
+}
+`;
+
+exports[`settingsSelectors > defaultAgent > should merge DEFAULT_AGENT and s.settings.defaultAgent correctly 1`] = `
+{
+  "config": {
+    "autoCreateTopicThreshold": 2,
+    "displayMode": "chat",
+    "enableAutoCreateTopic": true,
+    "historyCount": 1,
+    "model": "gpt-3.5-turbo",
+    "params": {
+      "frequency_penalty": 0,
+      "presence_penalty": 0,
+      "temperature": 0.6,
+      "top_p": 1,
+    },
+    "plugins": [],
+    "systemRole": "user",
+    "tts": {
+      "showAllLocaleVoice": false,
+      "sttLocale": "auto",
+      "ttsService": "openai",
+      "voice": {
+        "openai": "alloy",
+      },
+    },
+  },
+  "meta": {
+    "avatar": "agent-avatar.jpg",
+    "description": "Test agent",
+  },
+}
+`;
+
+exports[`settingsSelectors > defaultAgentConfig > should merge DEFAULT_AGENT_CONFIG and defaultAgent(s).config correctly 1`] = `
+{
+  "autoCreateTopicThreshold": 2,
+  "displayMode": "chat",
+  "enableAutoCreateTopic": true,
+  "historyCount": 1,
+  "model": "gpt-3.5-turbo",
+  "params": {
+    "frequency_penalty": 0,
+    "presence_penalty": 0,
+    "temperature": 0.7,
+    "top_p": 1,
+  },
+  "plugins": [],
+  "systemRole": "user",
+  "tts": {
+    "showAllLocaleVoice": false,
+    "sttLocale": "auto",
+    "ttsService": "openai",
+    "voice": {
+      "openai": "alloy",
+    },
+  },
+}
+`;
+
+exports[`settingsSelectors > defaultAgentMeta > should merge DEFAULT_AGENT_META and defaultAgent(s).meta correctly 1`] = `
+{
+  "avatar": "agent-avatar.jpg",
+  "description": "Test agent",
+}
+`;

package/src/store/global/slices/settings/action.ts

@@ -24,12 +24,12 @@ export interface SettingsAction {
    */
   resetSettings: () => void;
   setOpenAIConfig: (config: Partial<OpenAIConfig>) => void;
-
   /**
    * 设置部分配置设置
    * @param settings - 部分配置设置
    */
   setSettings: (settings: DeepPartial<GlobalSettings>) => void;
+
   switchSettingTabs: (tab: SettingsTabs) => void;
   /**
    * 设置主题模式
@@ -68,7 +68,6 @@ export const createSettingsSlice: StateCreator<
   setOpenAIConfig: (config) => {
     get().setSettings({ languageModel: { openAI: config } });
   },
-
   setSettings: (settings) => {
     const prevSetting = get().settings;
     const nextSettings = merge(prevSetting, settings);
@@ -77,6 +76,7 @@ export const createSettingsSlice: StateCreator<
 
     set({ settings: merge(prevSetting, settings) }, false, n('setSettings', settings));
   },
+
   switchSettingTabs: (tab) => {
     set({ settingsTab: tab });
   },