@lobehub/chat 1.56.1 → 1.56.3

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 # 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>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix inbox agent can not save config.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix inbox agent can not save config, closes [#6186](https://github.com/lobehub/lobe-chat/issues/6186) ([588cba7](https://github.com/lobehub/lobe-chat/commit/588cba7))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.56.1](https://github.com/lobehub/lobe-chat/compare/v1.56.0...v1.56.1)
 
 <sup>Released on **2025-02-16**</sup>

package/changelog/v1.json

@@ -1,4 +1,22 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Improve inbox agent settings."
+      ]
+    },
+    "date": "2025-02-16",
+    "version": "1.56.3"
+  },
+  {
+    "children": {
+      "fixes": [
+        "Fix inbox agent can not save config."
+      ]
+    },
+    "date": "2025-02-16",
+    "version": "1.56.2"
+  },
   {
     "children": {
       "fixes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.56.1",
+  "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/database/server/models/__tests__/session.test.ts

@@ -628,7 +628,7 @@ describe('SessionModel', () => {
 
   describe('createInbox', () => {
     it('should create inbox session if not exists', async () => {
-      const inbox = await sessionModel.createInbox();
+      const inbox = await sessionModel.createInbox({});
 
       expect(inbox).toBeDefined();
       expect(inbox?.slug).toBe('inbox');
@@ -641,10 +641,10 @@ describe('SessionModel', () => {
 
     it('should not create duplicate inbox session', async () => {
       // Create first inbox
-      await sessionModel.createInbox();
+      await sessionModel.createInbox({});
 
       // Try to create another inbox
-      const duplicateInbox = await sessionModel.createInbox();
+      const duplicateInbox = await sessionModel.createInbox({});
 
       // Should return undefined as inbox already exists
       expect(duplicateInbox).toBeUndefined();

package/src/database/server/models/session.ts

@@ -1,7 +1,7 @@
 import { Column, count, sql } from 'drizzle-orm';
 import { and, asc, desc, eq, gt, inArray, isNull, like, not, or } from 'drizzle-orm/expressions';
+import { DeepPartial } from 'utility-types';
 
-import { appEnv } from '@/config/app';
 import { DEFAULT_INBOX_AVATAR } from '@/const/meta';
 import { INBOX_SESSION_ID } from '@/const/session';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
@@ -13,7 +13,7 @@ import {
   genWhere,
 } from '@/database/utils/genWhere';
 import { idGenerator } from '@/database/utils/idGenerator';
-import { parseAgentConfig } from '@/server/globalConfig/parseDefaultAgent';
+import { LobeAgentConfig } from '@/types/agent';
 import { ChatSessionList, LobeAgentSession, SessionRankItem } from '@/types/session';
 import { merge } from '@/utils/merge';
 
@@ -226,16 +226,15 @@ export class SessionModel {
     });
   };
 
-  createInbox = async () => {
+  createInbox = async (defaultAgentConfig: DeepPartial<LobeAgentConfig>) => {
     const item = await this.db.query.sessions.findFirst({
       where: and(eq(sessions.userId, this.userId), eq(sessions.slug, INBOX_SESSION_ID)),
     });
-    if (item) return;
 
-    const serverAgentConfig = parseAgentConfig(appEnv.DEFAULT_AGENT_CONFIG) || {};
+    if (item) return;
 
     return await this.create({
-      config: merge(DEFAULT_AGENT_CONFIG, serverAgentConfig),
+      config: merge(DEFAULT_AGENT_CONFIG, defaultAgentConfig),
       slug: INBOX_SESSION_ID,
       type: 'agent',
     });

package/src/database/server/models/user.ts

@@ -10,7 +10,6 @@ import { merge } from '@/utils/merge';
 import { today } from '@/utils/time';
 
 import { NewUser, UserItem, UserSettingsItem, userSettings, users } from '../../schemas';
-import { SessionModel } from './session';
 
 type DecryptUserKeyVaults = (
   encryptKeyVaultsStr: string | null,
@@ -160,10 +159,7 @@ export class UserModel {
       .values({ ...params })
       .returning();
 
-    // Create an inbox session for the user
-    const model = new SessionModel(db, user.id);
-
-    await model.createInbox();
+    return user;
   };
 
   static deleteUser = async (db: LobeChatDatabase, id: string) => {

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/features/DevPanel/features/Table/TableCell.tsx

@@ -1,29 +1,27 @@
-import { Typography } from 'antd';
-import { createStyles } from 'antd-style';
 import dayjs from 'dayjs';
 import { get, isDate } from 'lodash-es';
 import React, { useMemo } from 'react';
 
-import TooltipContent from './TooltipContent';
+// import TooltipContent from './TooltipContent';
 
-const { Text } = Typography;
+// const { Text } = Typography;
 
-const useStyles = createStyles(({ token, css }) => ({
-  cell: css`
-    font-family: ${token.fontFamilyCode};
-    font-size: ${token.fontSizeSM}px;
-  `,
-  tooltip: css`
-    border: 1px solid ${token.colorBorder};
-
-    font-family: ${token.fontFamilyCode};
-    font-size: ${token.fontSizeSM}px;
-    color: ${token.colorText} !important;
-    word-break: break-all;
-
-    background: ${token.colorBgElevated} !important;
-  `,
-}));
+// const useStyles = createStyles(({ token, css }) => ({
+//   cell: css`
+//     font-family: ${token.fontFamilyCode};
+//     font-size: ${token.fontSizeSM}px;
+//   `,
+//   tooltip: css`
+//     border: 1px solid ${token.colorBorder};
+//
+//     font-family: ${token.fontFamilyCode};
+//     font-size: ${token.fontSizeSM}px;
+//     color: ${token.colorText} !important;
+//     word-break: break-all;
+//
+//     background: ${token.colorBgElevated} !important;
+//   `,
+// }));
 
 interface TableCellProps {
   column: string;
@@ -32,7 +30,7 @@ interface TableCellProps {
 }
 
 const TableCell = ({ dataItem, column, rowIndex }: TableCellProps) => {
-  const { styles } = useStyles();
+  // const { styles } = useStyles();
   const data = get(dataItem, column);
   const content = useMemo(() => {
     if (isDate(data)) return dayjs(data).format('YYYY-MM-DD HH:mm:ss');
@@ -54,18 +52,21 @@ const TableCell = ({ dataItem, column, rowIndex }: TableCellProps) => {
 
   return (
     <td key={column} onDoubleClick={() => console.log('Edit cell:', rowIndex, column)}>
-      <Text
-        className={styles.cell}
-        ellipsis={{
-          tooltip: {
-            arrow: false,
-            classNames: { body: styles.tooltip },
-            title: <TooltipContent>{content}</TooltipContent>,
-          },
-        }}
-      >
-        {content}
-      </Text>
+      {content}
+
+      {/* 不能使用 antd 的 Text， 会有大量的重渲染导致滚动极其卡顿 */}
+      {/*<Text*/}
+      {/*  className={styles.cell}*/}
+      {/*  ellipsis={{*/}
+      {/*    tooltip: {*/}
+      {/*      arrow: false,*/}
+      {/*      classNames: { body: styles.tooltip },*/}
+      {/*      title: <TooltipContent>{content}</TooltipContent>,*/}
+      {/*    },*/}
+      {/*  }}*/}
+      {/*>*/}
+      {/*  {content}*/}
+      {/*</Text>*/}
     </td>
   );
 };

package/src/libs/next-auth/adapter/index.ts

@@ -10,6 +10,7 @@ import { Adapter, AdapterAccount } from 'next-auth/adapters';
 
 import * as schema from '@/database/schemas';
 import { UserModel } from '@/database/server/models/user';
+import { AgentService } from '@/server/services/agent';
 import { merge } from '@/utils/merge';
 
 import {
@@ -65,6 +66,7 @@ export function LobeNextAuthDbAdapter(serverDB: NeonDatabase<typeof schema>): Ad
         const adapterUser = mapLobeUserToAdapterUser(existingUser);
         return adapterUser;
       }
+
       // create a new user if it does not exist
       await UserModel.createUser(
         serverDB,
@@ -77,6 +79,11 @@ export function LobeNextAuthDbAdapter(serverDB: NeonDatabase<typeof schema>): Ad
           name,
         }),
       );
+
+      // 3. Create an inbox session for the user
+      const agentService = new AgentService(serverDB, id);
+      await agentService.createInbox();
+
       return { ...user, id: providerAccountId ?? id };
     },
     async createVerificationToken(data): Promise<VerificationToken | null | undefined> {

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,
+      );
+    });
+  });
+});

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

@@ -10,6 +10,7 @@ import { SessionModel } from '@/database/server/models/session';
 import { UserModel } from '@/database/server/models/user';
 import { pino } from '@/libs/logger';
 import { authedProcedure, router } from '@/libs/trpc';
+import { AgentService } from '@/server/services/agent';
 import { KnowledgeItem, KnowledgeType } from '@/types/knowledgeBase';
 
 const agentProcedure = authedProcedure.use(async (opts) => {
@@ -18,6 +19,7 @@ const agentProcedure = authedProcedure.use(async (opts) => {
   return opts.next({
     ctx: {
       agentModel: new AgentModel(serverDB, ctx.userId),
+      agentService: new AgentService(serverDB, ctx.userId),
       fileModel: new FileModel(serverDB, ctx.userId),
       knowledgeBaseModel: new KnowledgeBaseModel(serverDB, ctx.userId),
       sessionModel: new SessionModel(serverDB, ctx.userId),
@@ -91,7 +93,7 @@ export const agentRouter = router({
           const user = await UserModel.findById(serverDB, ctx.userId);
           if (!user) return DEFAULT_AGENT_CONFIG;
 
-          const res = await ctx.sessionModel.createInbox();
+          const res = await ctx.agentService.createInbox();
           pino.info('create inbox session', res);
         }
       }

package/src/server/services/agent/index.test.ts

@@ -0,0 +1,65 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { SessionModel } from '@/database/server/models/session';
+import { parseAgentConfig } from '@/server/globalConfig/parseDefaultAgent';
+
+import { AgentService } from './index';
+
+vi.mock('@/config/app', () => ({
+  appEnv: {
+    DEFAULT_AGENT_CONFIG: 'model=gpt-4;temperature=0.7',
+  },
+}));
+
+vi.mock('@/server/globalConfig/parseDefaultAgent', () => ({
+  parseAgentConfig: vi.fn(),
+}));
+
+vi.mock('@/database/server/models/session', () => ({
+  SessionModel: vi.fn(),
+}));
+
+describe('AgentService', () => {
+  let service: AgentService;
+  const mockDb = {} as any;
+  const mockUserId = 'test-user-id';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    service = new AgentService(mockDb, mockUserId);
+  });
+
+  describe('createInbox', () => {
+    it('should create inbox with default agent config', async () => {
+      const mockConfig = { model: 'gpt-4', temperature: 0.7 };
+      const mockSessionModel = {
+        createInbox: vi.fn(),
+      };
+
+      (SessionModel as any).mockImplementation(() => mockSessionModel);
+      (parseAgentConfig as any).mockReturnValue(mockConfig);
+
+      await service.createInbox();
+
+      expect(SessionModel).toHaveBeenCalledWith(mockDb, mockUserId);
+      expect(parseAgentConfig).toHaveBeenCalledWith('model=gpt-4;temperature=0.7');
+      expect(mockSessionModel.createInbox).toHaveBeenCalledWith(mockConfig);
+    });
+
+    it('should create inbox with empty config if parseAgentConfig returns undefined', async () => {
+      const mockSessionModel = {
+        createInbox: vi.fn(),
+      };
+
+      (SessionModel as any).mockImplementation(() => mockSessionModel);
+      (parseAgentConfig as any).mockReturnValue(undefined);
+
+      await service.createInbox();
+
+      expect(SessionModel).toHaveBeenCalledWith(mockDb, mockUserId);
+      expect(parseAgentConfig).toHaveBeenCalledWith('model=gpt-4;temperature=0.7');
+      expect(mockSessionModel.createInbox).toHaveBeenCalledWith({});
+    });
+  });
+});

package/src/server/services/agent/index.ts

@@ -0,0 +1,22 @@
+import { appEnv } from '@/config/app';
+import { SessionModel } from '@/database/server/models/session';
+import { LobeChatDatabase } from '@/database/type';
+import { parseAgentConfig } from '@/server/globalConfig/parseDefaultAgent';
+
+export class AgentService {
+  private readonly userId: string;
+  private readonly db: LobeChatDatabase;
+
+  constructor(db: LobeChatDatabase, userId: string) {
+    this.userId = userId;
+    this.db = db;
+  }
+
+  async createInbox() {
+    const sessionModel = new SessionModel(this.db, this.userId);
+
+    const defaultAgentConfig = parseAgentConfig(appEnv.DEFAULT_AGENT_CONFIG) || {};
+
+    await sessionModel.createInbox(defaultAgentConfig);
+  }
+}

package/src/server/services/user/index.test.ts

@@ -4,6 +4,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { UserItem } from '@/database/schemas';
 import { UserModel } from '@/database/server/models/user';
 import { pino } from '@/libs/logger';
+import { AgentService } from '@/server/services/agent';
 
 import { UserService } from './index';
 
@@ -29,6 +30,12 @@ vi.mock('@/libs/logger', () => ({
   },
 }));
 
+vi.mock('@/server/services/agent', () => ({
+  AgentService: vi.fn().mockImplementation(() => ({
+    createInbox: vi.fn().mockResolvedValue(undefined),
+  })),
+}));
+
 let service: UserService;
 const mockUserId = 'test-user-id';
 
@@ -57,7 +64,7 @@ describe('UserService', () => {
       // Mock user not found
       vi.mocked(UserModel.findById).mockResolvedValue(null as any);
 
-      await service.createUser(mockUserId, mockUserJSON);
+      const result = await service.createUser(mockUserId, mockUserJSON);
 
       expect(UserModel.findById).toHaveBeenCalledWith(expect.anything(), mockUserId);
       expect(UserModel.createUser).toHaveBeenCalledWith(
@@ -73,6 +80,12 @@ describe('UserService', () => {
           clerkCreatedAt: new Date('2023-01-01T00:00:00Z'),
         }),
       );
+      expect(AgentService).toHaveBeenCalledWith(expect.anything(), mockUserId);
+      expect(vi.mocked(AgentService).mock.results[0].value.createInbox).toHaveBeenCalled();
+      expect(result).toEqual({
+        message: 'user created',
+        success: true,
+      });
     });
 
     it('should not create user if already exists', async () => {
@@ -83,6 +96,7 @@ describe('UserService', () => {
 
       expect(UserModel.findById).toHaveBeenCalledWith(expect.anything(), mockUserId);
       expect(UserModel.createUser).not.toHaveBeenCalled();
+      expect(AgentService).not.toHaveBeenCalled();
       expect(result).toEqual({
         message: 'user not created due to user already existing in the database',
         success: false,
@@ -106,6 +120,8 @@ describe('UserService', () => {
           phone: '+1234567890', // Should use first phone number
         }),
       );
+      expect(AgentService).toHaveBeenCalledWith(expect.anything(), mockUserId);
+      expect(vi.mocked(AgentService).mock.results[0].value.createInbox).toHaveBeenCalled();
     });
   });
 

package/src/server/services/user/index.ts

@@ -4,6 +4,7 @@ import { serverDB } from '@/database/server';
 import { UserModel } from '@/database/server/models/user';
 import { pino } from '@/libs/logger';
 import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
+import { AgentService } from '@/server/services/agent';
 
 export class UserService {
   createUser = async (id: string, params: UserJSON) => {
@@ -41,6 +42,10 @@ export class UserService {
       username: params.username,
     });
 
+    // 3. Create an inbox session for the user
+    const agentService = new AgentService(serverDB, id);
+    await agentService.createInbox();
+
     /* ↓ cloud slot ↓ */
 
     /* ↑ cloud slot ↑ */

package/src/services/session/client.ts

@@ -52,6 +52,18 @@ export class ClientService extends BaseClientService implements ISessionService
   };
 
   getSessionConfig: ISessionService['getSessionConfig'] = async (id) => {
+    if (id === INBOX_SESSION_ID) {
+      const item = await this.sessionModel.findByIdOrSlug(INBOX_SESSION_ID);
+
+      // if there is no session for user, create one
+      if (!item) {
+        const defaultAgentConfig =
+          window.global_serverConfigStore.getState().serverConfig.defaultAgent?.config || {};
+
+        await this.sessionModel.createInbox(defaultAgentConfig);
+      }
+    }
+
     const res = await this.sessionModel.findByIdOrSlug(id);
 
     if (!res) throw new Error('Session not found');