@lobehub/chat 0.108.0 → 0.109.0

package/src/services/__tests__/session.test.ts

@@ -0,0 +1,227 @@
+import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { SessionModel } from '@/database/models/session';
+import { LobeAgentConfig } from '@/types/agent';
+import { LobeAgentSession, LobeSessionType } from '@/types/session';
+
+import { sessionService } from '../session';
+
+// 请确保路径与你的项目结构匹配
+
+// Mock the SessionModel
+vi.mock('@/database/models/session', () => {
+  return {
+    SessionModel: {
+      create: vi.fn(),
+      query: vi.fn(),
+      delete: vi.fn(),
+      clearTable: vi.fn(),
+      update: vi.fn(),
+      batchCreate: vi.fn(),
+      isEmpty: vi.fn(),
+      queryByKeyword: vi.fn(),
+      updateConfig: vi.fn(),
+    },
+  };
+});
+
+describe('SessionService', () => {
+  const mockSessionId = 'mock-session-id';
+  const mockSession = {
+    id: mockSessionId,
+    type: 'agent',
+    meta: { title: 'Mock Session' },
+  } as LobeAgentSession;
+  const mockSessions = [mockSession];
+
+  beforeEach(() => {
+    // Reset all mocks before running each test case
+    vi.resetAllMocks();
+  });
+
+  describe('createNewSession', () => {
+    it('should create a new session and return its id', async () => {
+      // Setup
+      const sessionType = LobeSessionType.Agent;
+      const defaultValue = { meta: { title: 'New Session' } } as Partial<LobeAgentSession>;
+      (SessionModel.create as Mock).mockResolvedValue(mockSession);
+
+      // Execute
+      const sessionId = await sessionService.createNewSession(sessionType, defaultValue);
+
+      // Assert
+      expect(SessionModel.create).toHaveBeenCalledWith(sessionType, defaultValue);
+      expect(sessionId).toBe(mockSessionId);
+    });
+
+    it('should throw an error if session creation fails', async () => {
+      // Setup
+      const sessionType = LobeSessionType.Agent;
+      const defaultValue = { meta: { title: 'New Session' } } as Partial<LobeAgentSession>;
+      (SessionModel.create as Mock).mockResolvedValue(null);
+
+      // Execute & Assert
+      await expect(sessionService.createNewSession(sessionType, defaultValue)).rejects.toThrow(
+        'session create Error',
+      );
+    });
+  });
+  // ... (前面的测试代码)
+
+  describe('batchCreateSessions', () => {
+    it('should batch create sessions', async () => {
+      // Setup
+      (SessionModel.batchCreate as Mock).mockResolvedValue(mockSessions);
+
+      // Execute
+      const result = await sessionService.batchCreateSessions(mockSessions);
+
+      // Assert
+      expect(SessionModel.batchCreate).toHaveBeenCalledWith(mockSessions);
+      expect(result).toBe(mockSessions);
+    });
+  });
+  describe('getSessions', () => {
+    it('should retrieve sessions', async () => {
+      // Setup
+      (SessionModel.query as Mock).mockResolvedValue(mockSessions);
+
+      // Execute
+      const sessions = await sessionService.getSessions();
+
+      // Assert
+      expect(SessionModel.query).toHaveBeenCalled();
+      expect(sessions).toBe(mockSessions);
+    });
+  });
+
+  describe('getAllAgents', () => {
+    it('should retrieve all agent sessions', async () => {
+      // Setup
+      // Assuming that SessionModel.query has been modified to accept filters
+      const agentSessions = mockSessions.filter((session) => session.type === 'agent');
+      (SessionModel.query as Mock).mockResolvedValue(agentSessions);
+
+      // Execute
+      const result = await sessionService.getAllAgents();
+
+      // Assert
+      // Assuming that SessionModel.query would be called with a filter for agents
+      expect(SessionModel.query).toHaveBeenCalled(); // Add filter argument if applicable
+      expect(result).toBe(agentSessions);
+    });
+  });
+
+  describe('removeSession', () => {
+    it('should remove a session by its id', async () => {
+      // Setup
+      (SessionModel.delete as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await sessionService.removeSession(mockSessionId);
+
+      // Assert
+      expect(SessionModel.delete).toHaveBeenCalledWith(mockSessionId);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('removeAllSessions', () => {
+    it('should clear all sessions from the table', async () => {
+      // Setup
+      (SessionModel.clearTable as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await sessionService.removeAllSessions();
+
+      // Assert
+      expect(SessionModel.clearTable).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('updateSessionGroup', () => {
+    it('should update the group of a session', async () => {
+      // Setup
+      const groupId = 'new-group';
+      (SessionModel.update as Mock).mockResolvedValue({ ...mockSession, group: groupId });
+
+      // Execute
+      const result = await sessionService.updateSessionGroup(mockSessionId, groupId);
+
+      // Assert
+      expect(SessionModel.update).toHaveBeenCalledWith(mockSessionId, { group: groupId });
+      expect(result).toEqual({ ...mockSession, group: groupId });
+    });
+  });
+
+  describe('updateSessionMeta', () => {
+    it('should update the meta of a session', async () => {
+      // Setup
+      const newMeta = { description: 'Updated description' };
+      (SessionModel.update as Mock).mockResolvedValue({ ...mockSession, meta: newMeta });
+
+      // Execute
+      const result = await sessionService.updateSessionMeta(mockSessionId, newMeta);
+
+      // Assert
+      expect(SessionModel.update).toHaveBeenCalledWith(mockSessionId, { meta: newMeta });
+      expect(result).toEqual({ ...mockSession, meta: newMeta });
+    });
+  });
+
+  describe('updateSessionConfig', () => {
+    it('should update the config of a session', async () => {
+      // Setup
+      const newConfig = { compressThreshold: 2 } as LobeAgentConfig;
+      (SessionModel.updateConfig as Mock).mockResolvedValue({ ...mockSession, config: newConfig });
+
+      // Execute
+      const result = await sessionService.updateSessionConfig(mockSessionId, newConfig);
+
+      // Assert
+      expect(SessionModel.updateConfig).toHaveBeenCalledWith(mockSessionId, newConfig);
+      expect(result).toEqual({ ...mockSession, config: newConfig });
+    });
+  });
+  describe('hasSessions', () => {
+    it('should return false if no sessions exist', async () => {
+      // Setup
+      (SessionModel.isEmpty as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await sessionService.hasSessions();
+
+      // Assert
+      expect(SessionModel.isEmpty).toHaveBeenCalled();
+      expect(result).toBe(false);
+    });
+
+    it('should return true if sessions exist', async () => {
+      // Setup
+      (SessionModel.isEmpty as Mock).mockResolvedValue(false);
+
+      // Execute
+      const result = await sessionService.hasSessions();
+
+      // Assert
+      expect(SessionModel.isEmpty).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('searchSessions', () => {
+    it('should return sessions that match the keyword', async () => {
+      // Setup
+      const keyword = 'search';
+      (SessionModel.queryByKeyword as Mock).mockResolvedValue(mockSessions);
+
+      // Execute
+      const result = await sessionService.searchSessions(keyword);
+
+      // Assert
+      expect(SessionModel.queryByKeyword).toHaveBeenCalledWith(keyword);
+      expect(result).toBe(mockSessions);
+    });
+  });
+});

package/src/services/__tests__/topic.test.ts

@@ -0,0 +1,220 @@
+import { Mock, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { CreateTopicParams, TopicModel } from '@/database/models/topic';
+import { ChatTopic } from '@/types/topic';
+
+import { topicService } from '../topic';
+
+// Mock the TopicModel
+vi.mock('@/database/models/topic', () => {
+  return {
+    TopicModel: {
+      create: vi.fn(),
+      query: vi.fn(),
+      delete: vi.fn(),
+      batchDeleteBySessionId: vi.fn(),
+      batchDelete: vi.fn(),
+      clearTable: vi.fn(),
+      toggleFavorite: vi.fn(),
+      batchCreate: vi.fn(),
+      update: vi.fn(),
+      queryAll: vi.fn(),
+      queryByKeyword: vi.fn(),
+    },
+  };
+});
+
+describe('TopicService', () => {
+  // Mock data
+  const mockTopicId = 'mock-topic-id';
+  const mockTopic: ChatTopic = {
+    createdAt: 100,
+    updatedAt: 100,
+    id: mockTopicId,
+    title: 'Mock Topic',
+  };
+  const mockTopics = [mockTopic];
+
+  beforeEach(() => {
+    // Reset all mocks before running each test case
+    vi.resetAllMocks();
+  });
+
+  describe('createTopic', () => {
+    it('should create a topic and return its id', async () => {
+      // Setup
+      const createParams: CreateTopicParams = {
+        title: 'New Topic',
+        sessionId: '1',
+      };
+      (TopicModel.create as Mock).mockResolvedValue(mockTopic);
+
+      // Execute
+      const topicId = await topicService.createTopic(createParams);
+
+      // Assert
+      expect(TopicModel.create).toHaveBeenCalledWith(createParams);
+      expect(topicId).toBe(mockTopicId);
+    });
+    it('should throw an error if topic creation fails', async () => {
+      // Setup
+      const createParams: CreateTopicParams = {
+        title: 'New Topic',
+        sessionId: '1',
+      };
+
+      (TopicModel.create as Mock).mockResolvedValue(null);
+
+      // Execute & Assert
+      await expect(topicService.createTopic(createParams)).rejects.toThrow('topic create Error');
+    });
+  });
+
+  describe('getTopics', () => {
+    // Example for getTopics
+    it('should query topics with given parameters', async () => {
+      // Setup
+      const queryParams = { sessionId: 'session-id' };
+      (TopicModel.query as Mock).mockResolvedValue(mockTopics);
+
+      // Execute
+      const topics = await topicService.getTopics(queryParams);
+
+      // Assert
+      expect(TopicModel.query).toHaveBeenCalledWith(queryParams);
+      expect(topics).toBe(mockTopics);
+    });
+  });
+
+  describe('updateFavorite', () => {
+    // Example for updateFavorite
+    it('should toggle favorite status of a topic', async () => {
+      // Setup
+      const newState = true;
+      (TopicModel.toggleFavorite as Mock).mockResolvedValue({ ...mockTopic, favorite: newState });
+
+      // Execute
+      const result = await topicService.updateFavorite(mockTopicId, newState);
+
+      // Assert
+      expect(TopicModel.toggleFavorite).toHaveBeenCalledWith(mockTopicId, newState);
+      expect(result).toEqual({ ...mockTopic, favorite: newState });
+    });
+  });
+
+  describe('removeTopic', () => {
+    it('should remove a topic by id', async () => {
+      // Setup
+      (TopicModel.delete as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await topicService.removeTopic(mockTopicId);
+
+      // Assert
+      expect(TopicModel.delete).toHaveBeenCalledWith(mockTopicId);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('removeTopics', () => {
+    it('should remove all topics with a given session id', async () => {
+      // Setup
+      const sessionId = 'session-id';
+      (TopicModel.batchDeleteBySessionId as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await topicService.removeTopics(sessionId);
+
+      // Assert
+      expect(TopicModel.batchDeleteBySessionId).toHaveBeenCalledWith(sessionId);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('batchRemoveTopics', () => {
+    it('should batch remove topics', async () => {
+      // Setup
+      const topicIds = [mockTopicId, 'another-topic-id'];
+      (TopicModel.batchDelete as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await topicService.batchRemoveTopics(topicIds);
+
+      // Assert
+      expect(TopicModel.batchDelete).toHaveBeenCalledWith(topicIds);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('removeAllTopic', () => {
+    it('should clear all topics from the table', async () => {
+      // Setup
+      (TopicModel.clearTable as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await topicService.removeAllTopic();
+
+      // Assert
+      expect(TopicModel.clearTable).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('batchCreateTopics', () => {
+    it('should batch create topics', async () => {
+      // Setup
+      (TopicModel.batchCreate as Mock).mockResolvedValue(mockTopics);
+
+      // Execute
+      const result = await topicService.batchCreateTopics(mockTopics);
+
+      // Assert
+      expect(TopicModel.batchCreate).toHaveBeenCalledWith(mockTopics);
+      expect(result).toBe(mockTopics);
+    });
+  });
+
+  describe('updateTitle', () => {
+    it('should update the title of a topic', async () => {
+      // Setup
+      const newTitle = 'Updated Topic Title';
+      (TopicModel.update as Mock).mockResolvedValue({ ...mockTopic, title: newTitle });
+
+      // Execute
+      const result = await topicService.updateTitle(mockTopicId, newTitle);
+
+      // Assert
+      expect(TopicModel.update).toHaveBeenCalledWith(mockTopicId, { title: newTitle });
+      expect(result).toEqual({ ...mockTopic, title: newTitle });
+    });
+  });
+
+  describe('getAllTopics', () => {
+    it('should retrieve all topics', async () => {
+      // Setup
+      (TopicModel.queryAll as Mock).mockResolvedValue(mockTopics);
+
+      // Execute
+      const result = await topicService.getAllTopics();
+
+      // Assert
+      expect(TopicModel.queryAll).toHaveBeenCalled();
+      expect(result).toBe(mockTopics);
+    });
+  });
+
+  describe('searchTopics', () => {
+    it('should return topics that match the keyword', async () => {
+      // Setup
+      const keyword = 'search';
+      (TopicModel.queryByKeyword as Mock).mockResolvedValue(mockTopics);
+
+      // Execute
+      const result = await topicService.searchTopics(keyword);
+
+      // Assert
+      expect(TopicModel.queryByKeyword).toHaveBeenCalledWith(keyword);
+      expect(result).toBe(mockTopics);
+    });
+  });
+});

package/src/services/chat.ts

@@ -4,8 +4,8 @@ import { merge } from 'lodash-es';
 import { VISION_MODEL_WHITE_LIST } from '@/const/llm';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { filesSelectors, useFileStore } from '@/store/file';
-import { usePluginStore } from '@/store/plugin';
-import { pluginSelectors } from '@/store/plugin/selectors';
+import { useToolStore } from '@/store/tool';
+import { pluginSelectors } from '@/store/tool/selectors';
 import { ChatMessage } from '@/types/chatMessage';
 import type { OpenAIChatMessage, OpenAIChatStreamPayload } from '@/types/openai/chat';
 import { UserMessageContentPart } from '@/types/openai/chat';
@@ -41,7 +41,7 @@ class ChatService {
 
     // ============  2. preprocess tools   ============ //
 
-    const filterTools = pluginSelectors.enabledSchema(enabledPlugins)(usePluginStore.getState());
+    const filterTools = pluginSelectors.enabledSchema(enabledPlugins)(useToolStore.getState());
 
     // the rule that model can use tools:
     // 1. tools is not empty
@@ -79,9 +79,7 @@ class ChatService {
    * @param options
    */
   runPluginApi = async (params: PluginRequestPayload, options?: FetchOptions) => {
-    const { usePluginStore } = await import('@/store/plugin');
-
-    const s = usePluginStore.getState();
+    const s = useToolStore.getState();
 
     const settings = pluginSelectors.getPluginSettingsById(params.identifier)(s);
     const manifest = pluginSelectors.getPluginManifestById(params.identifier)(s);

package/src/services/plugin.ts

@@ -1,4 +1,4 @@
-import { LobeChatPluginsMarketIndex } from '@lobehub/chat-plugin-sdk';
+import { LobeChatPluginManifest, LobeChatPluginsMarketIndex } from '@lobehub/chat-plugin-sdk';
 
 import { getPluginIndexJSON } from '@/const/url';
 import { getCurrentLanguage } from '@/store/global/helpers';
@@ -16,6 +16,17 @@ class PluginService {
 
     return data;
   };
+
+  fetchManifest = async (manifest: string) => {
+    try {
+      const res = await fetch(manifest);
+
+      return (await res.json()) as LobeChatPluginManifest;
+    } catch (error) {
+      console.error(error);
+      return null;
+    }
+  };
 }
 
 export const pluginService = new PluginService();

package/src/store/chat/actions/message.test.ts

@@ -469,7 +469,6 @@ describe('chatMessage actions', () => {
       // 设置模拟返回值
       (messageService.getMessages as Mock).mockResolvedValue(messages);
 
-      // renderHook 在 @testing-library/react-hooks 中使用，所以我们使用 render 来替代
       const { result } = renderHook(() => useChatStore().useFetchMessages(sessionId, topicId));
 
       // 等待异步操作完成

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

@@ -3,6 +3,7 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { sessionService } from '@/services/session';
 import { useGlobalStore } from '@/store/global';
+import { agentSelectors } from '@/store/session/selectors';
 import { LobeAgentConfig } from '@/types/agent';
 import { MetaData } from '@/types/meta';
 
@@ -14,6 +15,7 @@ import { sessionSelectors } from '../session/selectors';
  */
 export interface AgentAction {
   removePlugin: (id: string) => void;
+  togglePlugin: (id: string, open?: boolean) => Promise<void>;
   updateAgentConfig: (config: Partial<LobeAgentConfig>) => void;
   updateAgentMeta: (meta: Partial<MetaData>) => void;
 }
@@ -25,19 +27,33 @@ export const createAgentSlice: StateCreator<
   AgentAction
 > = (set, get) => ({
   removePlugin: async (id) => {
-    const session = sessionSelectors.currentSession(get());
-    if (!session) return;
+    await get().togglePlugin(id, false);
+  },
 
-    const { activeId, refreshSessions } = get();
+  togglePlugin: async (id, open) => {
+    const originConfig = agentSelectors.currentAgentConfig(get());
 
-    const config = produce(session.config, (draft) => {
-      draft.plugins = draft.plugins?.filter((i) => i !== id) || [];
+    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 sessionService.updateSessionConfig(activeId, config);
-    await refreshSessions();
+    get().updateAgentConfig(config);
   },
-
   updateAgentConfig: async (config) => {
     // if is the inbox session, update the global config
     const isInbox = sessionSelectors.isInboxSession(get());

package/src/store/{plugin → tool}/helpers.ts

@@ -1,23 +1,12 @@
 import { LobeChatPluginMeta } from '@lobehub/chat-plugin-sdk';
-import i18n from 'i18next';
 
 import { CustomPlugin } from '@/types/plugin';
 
-const getI18nValue = (value: string | Record<string, string> | undefined) => {
-  if (!value) return;
-
-  if (typeof value === 'string') return value;
-
-  if (value[i18n.language]) return value[i18n.language];
-
-  return Object.values(value)[0];
-};
-
 const getPluginFormList = (pluginList: LobeChatPluginMeta[], id: string) =>
   pluginList?.find((p) => p.identifier === id);
 
-const getPluginTitle = (meta?: LobeChatPluginMeta['meta']) => getI18nValue(meta?.title);
-const getPluginDesc = (meta?: LobeChatPluginMeta['meta']) => getI18nValue(meta?.description);
+const getPluginTitle = (meta?: LobeChatPluginMeta['meta']) => meta?.title;
+const getPluginDesc = (meta?: LobeChatPluginMeta['meta']) => meta?.description;
 const getPluginAvatar = (meta?: LobeChatPluginMeta['meta']) => meta?.avatar;
 
 const isCustomPlugin = (id: string, pluginList: CustomPlugin[]) =>

package/src/store/tool/index.ts

@@ -0,0 +1,2 @@
+export * from './helpers';
+export { useToolStore } from './store';

package/src/store/tool/initialState.ts

@@ -0,0 +1,11 @@
+import { CustomPluginState, initialCustomPluginState } from './slices/customPlugin';
+import { PluginState, initialPluginState } from './slices/plugin';
+import { PluginStoreState, initialPluginStoreState } from './slices/store';
+
+export type ToolStoreState = PluginState & CustomPluginState & PluginStoreState;
+
+export const initialState: ToolStoreState = {
+  ...initialPluginState,
+  ...initialCustomPluginState,
+  ...initialPluginStoreState,
+};

package/src/store/tool/selectors.ts

@@ -0,0 +1,3 @@
+export { customPluginSelectors } from './slices/customPlugin/selectors';
+export { pluginSelectors } from './slices/plugin/selectors';
+export { pluginStoreSelectors } from './slices/store/selectors';