@lobehub/chat 1.56.2 → 1.56.3

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+### [Version 1.56.3](https://github.com/lobehub/lobe-chat/compare/v1.56.2...v1.56.3)
+
+<sup>Released on **2025-02-16**</sup>
+
+#### 💄 Styles
+
+- **misc**: Improve inbox agent settings.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Improve inbox agent settings, closes [#6197](https://github.com/lobehub/lobe-chat/issues/6197) ([37b70f0](https://github.com/lobehub/lobe-chat/commit/37b70f0))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.56.2](https://github.com/lobehub/lobe-chat/compare/v1.56.1...v1.56.2)
 
 <sup>Released on **2025-02-16**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Improve inbox agent settings."
+      ]
+    },
+    "date": "2025-02-16",
+    "version": "1.56.3"
+  },
   {
     "children": {
       "fixes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.56.2",
+  "version": "1.56.3",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/src/app/[variants]/(main)/chat/(workspace)/features/AgentSettings/CategoryContent/useCategory.tsx

@@ -27,11 +27,11 @@ export const useCategory = ({ mobile }: UseCategoryOptions = {}) => {
           key: ChatSettingsTabs.Meta,
           label: t('agentTab.meta'),
         }) as MenuItemType,
-        (!isInbox && {
+        {
           icon: <Icon icon={Bot} size={iconSize} />,
           key: ChatSettingsTabs.Prompt,
           label: t('agentTab.prompt'),
-        }) as MenuItemType,
+        },
         {
           icon: <Icon icon={MessagesSquare} size={iconSize} />,
           key: ChatSettingsTabs.Chat,

package/src/app/[variants]/(main)/chat/(workspace)/features/AgentSettings/index.tsx

@@ -41,7 +41,7 @@ const AgentSettings = memo(() => {
   ]);
   const isInbox = id === INBOX_SESSION_ID;
 
-  const [tab, setTab] = useState(isInbox ? ChatSettingsTabs.Chat : ChatSettingsTabs.Meta);
+  const [tab, setTab] = useState(isInbox ? ChatSettingsTabs.Prompt : ChatSettingsTabs.Meta);
 
   const ref = useRef<any>(null);
   const theme = useTheme();

package/src/features/AgentSetting/AgentMeta/index.tsx

@@ -9,6 +9,7 @@ import { memo } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import { FORM_STYLE } from '@/const/layoutTokens';
+import { INBOX_SESSION_ID } from '@/const/session';
 
 import { useStore } from '../store';
 import { SessionLoadingState } from '../store/initialState';
@@ -26,9 +27,11 @@ const AgentMeta = memo(() => {
     s.autocompleteMeta,
     s.autocompleteAllMeta,
   ]);
-  const loading = useStore((s) => s.autocompleteLoading);
+  const [isInbox, loading] = useStore((s) => [s.id === INBOX_SESSION_ID, s.autocompleteLoading]);
   const meta = useStore((s) => s.meta, isEqual);
 
+  if (isInbox) return;
+
   const basic = [
     {
       Render: AutoGenerateInput,

package/src/server/routers/lambda/agent.test.ts

@@ -0,0 +1,306 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { INBOX_SESSION_ID } from '@/const/session';
+import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
+import { serverDB } from '@/database/server';
+import { AgentModel } from '@/database/server/models/agent';
+import { FileModel } from '@/database/server/models/file';
+import { KnowledgeBaseModel } from '@/database/server/models/knowledgeBase';
+import { SessionModel } from '@/database/server/models/session';
+import { UserModel } from '@/database/server/models/user';
+import { AgentService } from '@/server/services/agent';
+import { KnowledgeType } from '@/types/knowledgeBase';
+
+import { agentRouter } from './agent';
+
+vi.mock('@/database/server/models/user', () => ({
+  UserModel: {
+    findById: vi.fn(),
+  },
+}));
+
+vi.mock('@/database/server/models/agent', () => ({
+  AgentModel: vi.fn(),
+}));
+
+vi.mock('@/database/server/models/session', () => ({
+  SessionModel: vi.fn(),
+}));
+
+vi.mock('@/database/server/models/file', () => ({
+  FileModel: vi.fn(),
+}));
+
+vi.mock('@/database/server/models/knowledgeBase', () => ({
+  KnowledgeBaseModel: vi.fn(),
+}));
+
+vi.mock('@/server/services/agent', () => ({
+  AgentService: vi.fn(),
+}));
+
+describe('agentRouter', () => {
+  const userId = 'testUserId';
+  let mockCtx: any;
+  let agentModelMock: any;
+  let sessionModelMock: any;
+  let fileModelMock: any;
+  let knowledgeBaseModelMock: any;
+  let agentServiceMock: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    agentModelMock = {
+      createAgentFiles: vi.fn(),
+      createAgentKnowledgeBase: vi.fn(),
+      deleteAgentFile: vi.fn(),
+      deleteAgentKnowledgeBase: vi.fn(),
+      findBySessionId: vi.fn(),
+      getAgentAssignedKnowledge: vi.fn(),
+      toggleFile: vi.fn(),
+      toggleKnowledgeBase: vi.fn(),
+    };
+    vi.mocked(AgentModel).mockImplementation(() => agentModelMock);
+
+    sessionModelMock = {
+      findByIdOrSlug: vi.fn(),
+    };
+    vi.mocked(SessionModel).mockImplementation(() => sessionModelMock);
+
+    fileModelMock = {
+      query: vi.fn(),
+    };
+    vi.mocked(FileModel).mockImplementation(() => fileModelMock);
+
+    knowledgeBaseModelMock = {
+      query: vi.fn(),
+    };
+    vi.mocked(KnowledgeBaseModel).mockImplementation(() => knowledgeBaseModelMock);
+
+    agentServiceMock = {
+      createInbox: vi.fn(),
+    };
+    vi.mocked(AgentService).mockImplementation(() => agentServiceMock);
+
+    mockCtx = {
+      userId,
+      agentModel: agentModelMock,
+      agentService: agentServiceMock,
+      fileModel: fileModelMock,
+      knowledgeBaseModel: knowledgeBaseModelMock,
+      sessionModel: sessionModelMock,
+    };
+  });
+
+  describe('getAgentConfig', () => {
+    it('should return default config if user not found when getting inbox config', async () => {
+      vi.mocked(UserModel.findById).mockResolvedValue(undefined);
+      sessionModelMock.findByIdOrSlug.mockResolvedValue(undefined);
+
+      const caller = agentRouter.createCaller(mockCtx);
+      const result = await caller.getAgentConfig({ sessionId: INBOX_SESSION_ID });
+
+      expect(result).toEqual(DEFAULT_AGENT_CONFIG);
+    });
+
+    it('should create inbox session if user exists but no inbox session', async () => {
+      const mockUser = { id: userId };
+      const mockSession = { id: 'inboxSessionId' };
+
+      vi.mocked(UserModel.findById).mockResolvedValue(mockUser as any);
+      sessionModelMock.findByIdOrSlug
+        .mockResolvedValueOnce(undefined)
+        .mockResolvedValueOnce(mockSession);
+      agentModelMock.findBySessionId.mockResolvedValue(DEFAULT_AGENT_CONFIG);
+
+      const caller = agentRouter.createCaller(mockCtx);
+      const result = await caller.getAgentConfig({ sessionId: INBOX_SESSION_ID });
+
+      expect(agentServiceMock.createInbox).toHaveBeenCalled();
+      expect(result).toEqual(DEFAULT_AGENT_CONFIG);
+    });
+
+    it('should find agent by session id if session exists', async () => {
+      const mockSession = { id: 'session1' };
+      sessionModelMock.findByIdOrSlug.mockResolvedValue(mockSession);
+      agentModelMock.findBySessionId.mockResolvedValue(DEFAULT_AGENT_CONFIG);
+
+      const caller = agentRouter.createCaller(mockCtx);
+      const result = await caller.getAgentConfig({ sessionId: 'session1' });
+
+      expect(agentModelMock.findBySessionId).toHaveBeenCalledWith('session1');
+      expect(result).toEqual(DEFAULT_AGENT_CONFIG);
+    });
+  });
+
+  describe('getKnowledgeBasesAndFiles', () => {
+    it('should return combined knowledge bases and files', async () => {
+      const mockFiles = [
+        { id: 'file1', name: 'File 1', fileType: 'text' },
+        { id: 'file2', name: 'File 2', fileType: 'pdf' },
+      ];
+
+      const mockKnowledgeBases = [
+        { id: 'kb1', name: 'KB 1', description: 'desc 1', avatar: 'avatar1' },
+        { id: 'kb2', name: 'KB 2', description: 'desc 2', avatar: 'avatar2' },
+      ];
+
+      const mockKnowledge = {
+        files: [{ id: 'file1', enabled: true }],
+        knowledgeBases: [{ id: 'kb1', enabled: true }],
+      };
+
+      fileModelMock.query.mockResolvedValue(mockFiles);
+      knowledgeBaseModelMock.query.mockResolvedValue(mockKnowledgeBases);
+      agentModelMock.getAgentAssignedKnowledge.mockResolvedValue(mockKnowledge);
+
+      const caller = agentRouter.createCaller(mockCtx);
+      const result = await caller.getKnowledgeBasesAndFiles({ agentId: 'agent1' });
+
+      expect(result).toEqual([
+        {
+          enabled: true,
+          fileType: 'text',
+          id: 'file1',
+          name: 'File 1',
+          type: KnowledgeType.File,
+        },
+        {
+          enabled: false,
+          fileType: 'pdf',
+          id: 'file2',
+          name: 'File 2',
+          type: KnowledgeType.File,
+        },
+        {
+          avatar: 'avatar1',
+          description: 'desc 1',
+          enabled: true,
+          id: 'kb1',
+          name: 'KB 1',
+          type: KnowledgeType.KnowledgeBase,
+        },
+        {
+          avatar: 'avatar2',
+          description: 'desc 2',
+          enabled: false,
+          id: 'kb2',
+          name: 'KB 2',
+          type: KnowledgeType.KnowledgeBase,
+        },
+      ]);
+    });
+  });
+
+  describe('createAgentFiles', () => {
+    it('should create agent files', async () => {
+      const mockInput = {
+        agentId: 'agent1',
+        fileIds: ['file1', 'file2'],
+        enabled: true,
+      };
+
+      const caller = agentRouter.createCaller(mockCtx);
+      await caller.createAgentFiles(mockInput);
+
+      expect(agentModelMock.createAgentFiles).toHaveBeenCalledWith(
+        mockInput.agentId,
+        mockInput.fileIds,
+        mockInput.enabled,
+      );
+    });
+  });
+
+  describe('deleteAgentFile', () => {
+    it('should delete agent file', async () => {
+      const mockInput = {
+        agentId: 'agent1',
+        fileId: 'file1',
+      };
+
+      const caller = agentRouter.createCaller(mockCtx);
+      await caller.deleteAgentFile(mockInput);
+
+      expect(agentModelMock.deleteAgentFile).toHaveBeenCalledWith(
+        mockInput.agentId,
+        mockInput.fileId,
+      );
+    });
+  });
+
+  describe('toggleFile', () => {
+    it('should toggle file', async () => {
+      const mockInput = {
+        agentId: 'agent1',
+        fileId: 'file1',
+        enabled: true,
+      };
+
+      const caller = agentRouter.createCaller(mockCtx);
+      await caller.toggleFile(mockInput);
+
+      expect(agentModelMock.toggleFile).toHaveBeenCalledWith(
+        mockInput.agentId,
+        mockInput.fileId,
+        mockInput.enabled,
+      );
+    });
+  });
+
+  describe('createAgentKnowledgeBase', () => {
+    it('should create agent knowledge base', async () => {
+      const mockInput = {
+        agentId: 'agent1',
+        knowledgeBaseId: 'kb1',
+        enabled: true,
+      };
+
+      const caller = agentRouter.createCaller(mockCtx);
+      await caller.createAgentKnowledgeBase(mockInput);
+
+      expect(agentModelMock.createAgentKnowledgeBase).toHaveBeenCalledWith(
+        mockInput.agentId,
+        mockInput.knowledgeBaseId,
+        mockInput.enabled,
+      );
+    });
+  });
+
+  describe('deleteAgentKnowledgeBase', () => {
+    it('should delete agent knowledge base', async () => {
+      const mockInput = {
+        agentId: 'agent1',
+        knowledgeBaseId: 'kb1',
+      };
+
+      const caller = agentRouter.createCaller(mockCtx);
+      await caller.deleteAgentKnowledgeBase(mockInput);
+
+      expect(agentModelMock.deleteAgentKnowledgeBase).toHaveBeenCalledWith(
+        mockInput.agentId,
+        mockInput.knowledgeBaseId,
+      );
+    });
+  });
+
+  describe('toggleKnowledgeBase', () => {
+    it('should toggle knowledge base', async () => {
+      const mockInput = {
+        agentId: 'agent1',
+        knowledgeBaseId: 'kb1',
+        enabled: true,
+      };
+
+      const caller = agentRouter.createCaller(mockCtx);
+      await caller.toggleKnowledgeBase(mockInput);
+
+      expect(agentModelMock.toggleKnowledgeBase).toHaveBeenCalledWith(
+        mockInput.agentId,
+        mockInput.knowledgeBaseId,
+        mockInput.enabled,
+      );
+    });
+  });
+});