@lobehub/chat 0.105.2 → 0.107.0

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

@@ -3,20 +3,13 @@ import { LanguageModel } from '@/types/llm';
 import { LobeAgentSession, LobeSessionType } from '@/types/session';
 
 import { initLobeSession } from '../initialState';
-import {
-  currentSession,
-  currentSessionSafe,
-  getSessionById,
-  getSessionMetaById,
-  hasSessionList,
-  sessionList,
-} from './list';
+import { sessionSelectors } from './list';
 
 describe('currentSession', () => {
   const s = {
     activeId: '1',
-    sessions: {
-      '1': {
+    sessions: [
+      {
         id: '1',
         config: {
           model: LanguageModel.GPT3_5,
@@ -25,7 +18,7 @@ describe('currentSession', () => {
         },
         type: LobeSessionType.Agent,
       } as LobeAgentSession,
-      '2': {
+      {
         id: '2',
         config: {
           model: LanguageModel.GPT3_5,
@@ -34,36 +27,23 @@ describe('currentSession', () => {
         },
         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);
+    expect(sessionSelectors.currentSession({ sessions: {} } as any)).toBeUndefined();
   });
 
   it('should return s.sessions[s.activeId] when s.activeId is not equal to INBOX_SESSION_ID', () => {
-    expect(currentSession(s)).toEqual(s.sessions['1']);
+    expect(sessionSelectors.currentSession(s)).toEqual(s.sessions[0]);
   });
 });
 
 describe('currentSessionSafe', () => {
   const s = {
     activeId: '1',
-    sessions: {
-      '1': {
+    sessions: [
+      {
         id: '1',
         config: {
           model: LanguageModel.GPT3_5,
@@ -72,7 +52,7 @@ describe('currentSessionSafe', () => {
         },
         type: LobeSessionType.Agent,
       } as LobeAgentSession,
-      '2': {
+      {
         id: '2',
         config: {
           model: LanguageModel.GPT3_5,
@@ -81,151 +61,23 @@ describe('currentSessionSafe', () => {
         },
         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);
+    expect(sessionSelectors.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);
+    expect(sessionSelectors.currentSessionSafe(s)).toEqual(s.sessions[0]);
   });
 });
 
 describe('getSessionById', () => {
   const s = {
     activeId: '1',
-    sessions: {
-      '1': {
+    sessions: [
+      {
         id: '1',
         config: {
           model: LanguageModel.GPT3_5,
@@ -234,7 +86,7 @@ describe('getSessionById', () => {
         },
         type: LobeSessionType.Agent,
       } as LobeAgentSession,
-      '2': {
+      {
         id: '2',
         config: {
           model: LanguageModel.GPT3_5,
@@ -243,61 +95,31 @@ describe('getSessionById', () => {
         },
         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']);
+    expect(sessionSelectors.getSessionById('1')(s)).toEqual(s.sessions[0]);
   });
 
   it('should return initLobeSession when the session with the specified id does not exist', () => {
-    expect(getSessionById('3')(s)).toEqual(initLobeSession);
+    expect(sessionSelectors.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',
-      },
-    },
+    sessions: [
+      { id: '1', meta: { title: 'Session 1' } },
+      { id: '2', meta: { title: 'Session 2' } },
+    ],
   } 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' });
+    expect(sessionSelectors.getSessionMetaById('1')(s)).toEqual({ title: 'Session 1' });
   });
 
   it('should return an empty object when the session with the specified id does not exist', () => {
-    expect(getSessionMetaById('3')(s)).toEqual({});
+    expect(sessionSelectors.getSessionMetaById('3')(s)).toEqual({});
   });
 });

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

@@ -1,68 +1,27 @@
 import { INBOX_SESSION_ID } from '@/const/session';
+import { sessionHelpers } from '@/store/session/slices/session/helpers';
 import { MetaData } from '@/types/meta';
-import { LobeAgentSession } from '@/types/session';
-import { filterWithKeywords } from '@/utils/filter';
+import { LobeAgentSession, LobeSessions, SessionGroupDefaultKeys } from '@/types/session';
 
 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;
+const defaultSessions = (s: SessionStore): LobeSessions => s.sessions;
 
-  return s.sessions[s.activeId];
-};
+const searchSessions = (s: SessionStore): LobeSessions => s.searchSessions;
 
-export const currentSessionSafe = (s: SessionStore): LobeAgentSession => {
-  return currentSession(s) || initLobeSession;
-};
-
-export const sessionList = (s: SessionStore) => {
-  const filterChats = filterWithKeywords(s.sessions, s.searchKeywords, (item) => [
-    Object.values(item.chats || {})
-      .map((c) => c.content)
-      .join(''),
-  ]);
-  // 先按照 `pinned` 字段进行排序，置顶的会排在前面。然后，根据 `updateAt` 字段进行倒序排序。
-  return Object.values(filterChats).sort((a, b) => {
-    if (a.pinned && !b.pinned) {
-      return -1;
-    }
-    if (!a.pinned && b.pinned) {
-      return 1;
-    }
-    if (a.updateAt && b.updateAt) {
-      return b.updateAt - a.updateAt;
-    }
-    return 0;
-  });
-};
+const pinnedSessionList = (s: SessionStore) =>
+  defaultSessions(s).filter((s) => s.group === SessionGroupDefaultKeys.Pinned);
 
-export const pinnedSessionList = (s: SessionStore) => sessionList(s).filter((s) => s.pinned);
-export const unpinnedSessionList = (s: SessionStore) => sessionList(s).filter((s) => !s.pinned);
-
-export const hasSessionList = (s: SessionStore) => {
-  const list = sessionList(s);
-  return list?.length > 0;
-};
-export const hasPinnedSessionList = (s: SessionStore) => {
-  const list = pinnedSessionList(s);
-  return list?.length > 0;
-};
+const unpinnedSessionList = (s: SessionStore) =>
+  defaultSessions(s).filter((s) => s.group === SessionGroupDefaultKeys.Default);
 
-export const getSessionById =
+const getSessionById =
   (id: string) =>
-  (s: SessionStore): LobeAgentSession => {
-    if (id === INBOX_SESSION_ID) return s.inbox;
+  (s: SessionStore): LobeAgentSession =>
+    sessionHelpers.getSessionById(id, s.sessions);
 
-    const session = s.sessions[id];
-
-    if (!session) return initLobeSession;
-    return session;
-  };
-
-export const getSessionMetaById =
+const getSessionMetaById =
   (id: string) =>
   (s: SessionStore): MetaData => {
     const session = getSessionById(id)(s);
@@ -71,31 +30,34 @@ export const getSessionMetaById =
     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;
-// };
+const currentSession = (s: SessionStore): LobeAgentSession | undefined => {
+  if (!s.activeId) return;
+
+  return s.sessions.find((i) => i.id === s.activeId);
+};
+
+const currentSessionSafe = (s: SessionStore): LobeAgentSession => {
+  return currentSession(s) || initLobeSession;
+};
 
-export const hasConversion = (s: SessionStore) => {
-  const hasCustomAgents = !!Object.keys(s.sessions).length;
-  const hasMessageInInbox = !!Object.keys(s.inbox.chats).length;
+const hasPinnedSessionList = (s: SessionStore) => {
+  const list = pinnedSessionList(s);
+  return list?.length > 0;
+};
 
-  return hasCustomAgents || hasMessageInInbox;
+const hasCustomAgents = (s: SessionStore) => defaultSessions(s).length > 0;
+
+const isInboxSession = (s: SessionStore) => s.activeId === INBOX_SESSION_ID;
+
+export const sessionSelectors = {
+  currentSession,
+  currentSessionSafe,
+  getSessionById,
+  getSessionMetaById,
+  hasCustomAgents,
+  hasPinnedSessionList,
+  isInboxSession,
+  pinnedSessionList,
+  searchSessions,
+  unpinnedSessionList,
 };

package/src/store/session/store.ts

@@ -1,4 +1,4 @@
-import { PersistOptions, devtools, persist } from 'zustand/middleware';
+import { PersistOptions, devtools, persist, subscribeWithSelector } from 'zustand/middleware';
 import { shallow } from 'zustand/shallow';
 import { createWithEqualityFn } from 'zustand/traditional';
 import { StateCreator } from 'zustand/vanilla';
@@ -8,54 +8,48 @@ import { isDev } from '@/utils/env';
 import { createHyperStorage } from '../middleware/createHyperStorage';
 import { SessionStoreState, initialState } from './initialState';
 import { AgentAction, createAgentSlice } from './slices/agent/action';
-import { ChatAction, createChatSlice } from './slices/chat/actions';
 import { SessionAction, createSessionSlice } from './slices/session/action';
 
 //  ===============  聚合 createStoreFn ============ //
 
-export type SessionStore = SessionAction & AgentAction & ChatAction & SessionStoreState;
+export type SessionStore = SessionAction & AgentAction & SessionStoreState;
 const createStore: StateCreator<SessionStore, [['zustand/devtools', never]]> = (...parameters) => ({
   ...initialState,
   ...createAgentSlice(...parameters),
   ...createSessionSlice(...parameters),
-  ...createChatSlice(...parameters),
 });
 
 //  ===============  persist 本地缓存中间件配置 ============ //
 
-const LOBE_CHAT = 'LOBE_CHAT';
-
 const persistOptions: PersistOptions<SessionStore> = {
-  name: LOBE_CHAT,
+  name: 'LOBE_CHAT',
 
   // 手动控制 Hydration ，避免 ssr 报错
   skipHydration: true,
 
   storage: createHyperStorage({
-    localStorage: {
-      dbName: 'LobeHub',
-      mode: 'indexedDB',
-      selectors: ['inbox', 'sessions'],
-    },
+    localStorage: false,
     url: {
       mode: 'hash',
       selectors: [
         // map state key to storage key
         { activeId: 'session' },
-        { activeTopicId: 'topic' },
       ],
     },
   }),
-  version: 0,
+
+  version: 2,
 };
 
 //  ===============  实装 useStore ============ //
 
 export const useSessionStore = createWithEqualityFn<SessionStore>()(
   persist(
-    devtools(createStore, {
-      name: LOBE_CHAT + (isDev ? '_DEV' : ''),
-    }),
+    subscribeWithSelector(
+      devtools(createStore, {
+        name: 'LobeChat_Session' + (isDev ? '_DEV' : ''),
+      }),
+    ),
     persistOptions,
   ),
   shallow,

package/src/types/agent/index.ts

@@ -0,0 +1,61 @@
+import { FewShots, LLMParams, LanguageModel } from '@/types/llm';
+
+export type TTSServer = 'openai' | 'edge' | 'microsoft';
+
+export interface LobeAgentTTSConfig {
+  showAllLocaleVoice?: boolean;
+  sttLocale: 'auto' | string;
+  ttsService: TTSServer;
+  voice: {
+    edge?: string;
+    microsoft?: string;
+    openai: string;
+  };
+}
+export interface LobeAgentConfig {
+  autoCreateTopicThreshold: number;
+  compressThreshold?: number;
+  displayMode?: 'chat' | 'docs';
+  enableAutoCreateTopic: boolean;
+  /**
+   * 历史消息长度压缩阈值
+   */
+  enableCompressThreshold?: boolean;
+  /**
+   * 开启历史记录条数
+   */
+  enableHistoryCount?: boolean;
+  enableMaxTokens?: boolean;
+
+  fewShots?: FewShots;
+  /**
+   * 历史消息条数
+   */
+  historyCount?: number;
+  inputTemplate?: string;
+  /**
+   * 角色所使用的语言模型
+   * @default gpt-3.5-turbo
+   */
+  model: LanguageModel | string;
+  /**
+   * 语言模型参数
+   */
+  params: LLMParams;
+  /**
+   * 启用的插件
+   */
+  plugins?: string[];
+  /**
+   * 系统角色
+   */
+  systemRole: string;
+  /**
+   * 语音服务
+   */
+  tts: LobeAgentTTSConfig;
+}
+
+export type LobeAgentConfigKeys =
+  | keyof LobeAgentConfig
+  | ['params', keyof LobeAgentConfig['params']];

package/src/types/chatMessage.ts

@@ -1,5 +1,3 @@
-import { PluginRequestPayload } from '@lobehub/chat-plugin-sdk';
-
 import { ErrorType } from '@/types/fetch';
 import { Translate } from '@/types/translate';
 
@@ -14,10 +12,6 @@ export interface ChatMessageError {
   message: string;
   type: ErrorType;
 }
-export interface OpenAIFunctionCall {
-  arguments?: string;
-  name: string;
-}
 
 export interface ChatTranslate extends Translate {
   content?: string;
@@ -26,33 +20,29 @@ export interface ChatTranslate extends Translate {
 export interface ChatTTS {
   init?: boolean;
 }
+
+export interface ChatPluginPayload {
+  apiName: string;
+  arguments: string;
+  identifier: string;
+  type: 'standalone' | 'default';
+}
+
 export interface ChatMessage extends BaseDataModel {
-  /**
-   * @title 内容
-   * @description 消息内容
-   */
   content: string;
   error?: any;
   // 扩展字段
   extra?: {
     fromModel?: string;
     // 翻译
-    translate?: ChatTranslate;
+    translate?: ChatTranslate | null;
     // TTS
     tts?: ChatTTS;
   } & Record<string, any>;
 
   files?: string[];
-  /**
-   * replace with plugin
-   * @deprecated
-   */
-  function_call?: OpenAIFunctionCall;
-
-  name?: string;
-
   parentId?: string;
-  plugin?: PluginRequestPayload;
+  plugin?: ChatPluginPayload;
 
   pluginState?: any;
   // 引用
@@ -62,6 +52,7 @@ export interface ChatMessage extends BaseDataModel {
    * @description 消息发送者的角色
    */
   role: LLMRoleType;
+  sessionId?: string;
   /**
    * 保存到主题的消息
    */

package/src/types/exportConfig.ts

@@ -1,5 +1,7 @@
-import { LobeAgentSession, LobeSessions } from '@/types/session';
+import { ChatMessage } from '@/types/chatMessage';
+import { LobeSessions } from '@/types/session';
 import { GlobalSettings } from '@/types/settings';
+import { ChatTopic } from '@/types/topic';
 
 /**
  * 导出方式
@@ -40,15 +42,18 @@ export interface ConfigModelMap {
  * 配置状态：会话
  */
 export interface ConfigStateSessions {
-  inbox: LobeAgentSession;
+  messages: ChatMessage[];
   sessions: LobeSessions;
+  topics: ChatTopic[];
 }
 
 /**
  * 配置状态：单个会话
  */
 export interface ConfigStateSingleSession {
+  messages: ChatMessage[];
   sessions: LobeSessions;
+  topics: ChatTopic[];
 }
 
 /**

package/src/types/files.ts

@@ -1,6 +1,6 @@
-import { LocalFile } from './database/files';
+import { DB_File } from '../database/schemas/files';
 
-export interface FilePreview extends Pick<LocalFile, 'saveMode' | 'fileType'> {
+export interface FilePreview extends Pick<DB_File, 'saveMode' | 'fileType'> {
   base64Url?: string;
   data?: ArrayBuffer;
   name: string;