@lobehub/lobehub 2.0.0-next.266 → 2.0.0-next.268

package/packages/database/migrations/meta/_journal.json

@@ -476,6 +476,13 @@
       "when": 1767929492232,
       "tag": "0067_add_agent_cron_tables",
       "breakpoints": true
+    },
+    {
+      "idx": 68,
+      "version": "7",
+      "when": 1768189437504,
+      "tag": "0068_update_group_data",
+      "breakpoints": true
     }
   ],
   "version": "6"

package/packages/database/src/models/__tests__/chatGroup.test.ts

@@ -4,6 +4,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { LobeChatDatabase } from '@/database/type';
 
+import { getTestDB } from '../../core/getTestDB';
 import {
   NewChatGroup,
   agents as agentsTable,
@@ -12,7 +13,6 @@ import {
   users,
 } from '../../schemas';
 import { ChatGroupModel } from '../chatGroup';
-import { getTestDB } from '../../core/getTestDB';
 
 const userId = 'test-user';
 const otherUserId = 'other-user';
@@ -226,9 +226,8 @@ describe('ChatGroupModel', () => {
         description: 'A test chat group',
         pinned: true,
         config: {
-          maxResponseInRow: 5,
-          responseOrder: 'sequential',
-          scene: 'casual',
+          allowDM: true,
+          revealDM: false,
         },
       };
 
@@ -240,9 +239,8 @@ describe('ChatGroupModel', () => {
       expect(result.description).toBe('A test chat group');
       expect(result.pinned).toBe(true);
       expect(result.config).toEqual({
-        maxResponseInRow: 5,
-        responseOrder: 'sequential',
-        scene: 'casual',
+        allowDM: true,
+        revealDM: false,
       });
       expect(result.id.startsWith('cg_')).toBe(true);
     });

package/packages/database/src/models/__tests__/knowledgeBase.test.ts

@@ -6,6 +6,7 @@ import { sleep } from '@/utils/sleep';
 
 import {
   NewKnowledgeBase,
+  documents,
   files,
   globalFiles,
   knowledgeBaseFiles,
@@ -193,6 +194,132 @@ describe('KnowledgeBaseModel', () => {
       });
       expect(addedFiles).toHaveLength(2);
     });
+
+    it('should add documents (with docs_ prefix) to a knowledge base by resolving to file IDs', async () => {
+      await serverDB.insert(globalFiles).values([
+        {
+          hashId: 'hash1',
+          url: 'https://example.com/document.pdf',
+          size: 1000,
+          fileType: 'application/pdf',
+          creator: userId,
+        },
+      ]);
+
+      // Create document first
+      await serverDB.insert(documents).values([
+        {
+          id: 'docs_test123',
+          title: 'Test Document',
+          content: 'Test content',
+          fileType: 'application/pdf',
+          totalCharCount: 100,
+          totalLineCount: 10,
+          sourceType: 'file',
+          source: 'test.pdf',
+          userId,
+        },
+      ]);
+
+      // Create mirror file with parentId pointing to the document
+      await serverDB.insert(files).values([
+        {
+          id: 'file1',
+          name: 'document.pdf',
+          url: 'https://example.com/document.pdf',
+          fileHash: 'hash1',
+          size: 1000,
+          fileType: 'application/pdf',
+          parentId: 'docs_test123', // Mirror file points to document
+          userId,
+        },
+      ]);
+
+      const { id: knowledgeBaseId } = await knowledgeBaseModel.create({ name: 'Test Group' });
+
+      // Pass document ID (with docs_ prefix)
+      const result = await knowledgeBaseModel.addFilesToKnowledgeBase(knowledgeBaseId, [
+        'docs_test123',
+      ]);
+
+      // Should resolve to file1 and insert that
+      expect(result).toHaveLength(1);
+      expect(result[0].fileId).toBe('file1');
+      expect(result[0].knowledgeBaseId).toBe(knowledgeBaseId);
+
+      const addedFiles = await serverDB.query.knowledgeBaseFiles.findMany({
+        where: eq(knowledgeBaseFiles.knowledgeBaseId, knowledgeBaseId),
+      });
+      expect(addedFiles).toHaveLength(1);
+      expect(addedFiles[0].fileId).toBe('file1');
+
+      // Verify document.knowledgeBaseId was updated
+      const document = await serverDB.query.documents.findFirst({
+        where: eq(documents.id, 'docs_test123'),
+      });
+      expect(document?.knowledgeBaseId).toBe(knowledgeBaseId);
+    });
+
+    it('should handle mixed document IDs and file IDs', async () => {
+      await serverDB.insert(globalFiles).values([
+        {
+          hashId: 'hash1',
+          url: 'https://example.com/document.pdf',
+          size: 1000,
+          fileType: 'application/pdf',
+          creator: userId,
+        },
+        {
+          hashId: 'hash2',
+          url: 'https://example.com/image.jpg',
+          size: 500,
+          fileType: 'image/jpeg',
+          creator: userId,
+        },
+      ]);
+
+      // Create document first
+      await serverDB.insert(documents).values([
+        {
+          id: 'docs_test456',
+          title: 'Test Document',
+          content: 'Test content',
+          fileType: 'application/pdf',
+          totalCharCount: 100,
+          totalLineCount: 10,
+          sourceType: 'file',
+          source: 'test.pdf',
+          userId,
+        },
+      ]);
+
+      // Create files - file1 is mirror of the document, file2 is standalone
+      await serverDB.insert(files).values([
+        {
+          id: 'file1',
+          name: 'document.pdf',
+          url: 'https://example.com/document.pdf',
+          fileHash: 'hash1',
+          size: 1000,
+          fileType: 'application/pdf',
+          parentId: 'docs_test456', // Mirror file points to document
+          userId,
+        },
+        fileList[1], // file2 - standalone file
+      ]);
+
+      const { id: knowledgeBaseId } = await knowledgeBaseModel.create({ name: 'Test Group' });
+
+      // Mix of document ID and direct file ID
+      const result = await knowledgeBaseModel.addFilesToKnowledgeBase(knowledgeBaseId, [
+        'docs_test456',
+        'file2',
+      ]);
+
+      expect(result).toHaveLength(2);
+      const fileIds = result.map((r) => r.fileId).sort();
+      expect(fileIds).toEqual(['file1', 'file2']);
+    });
   });
 
   describe('removeFilesFromKnowledgeBase', () => {
@@ -230,6 +357,64 @@ describe('KnowledgeBaseModel', () => {
       expect(remainingFiles[0].fileId).toBe('file2');
     });
 
+    it('should remove documents (with docs_ prefix) from a knowledge base by resolving to file IDs', async () => {
+      await serverDB.insert(globalFiles).values([
+        {
+          hashId: 'hash1',
+          url: 'https://example.com/document.pdf',
+          size: 1000,
+          fileType: 'application/pdf',
+          creator: userId,
+        },
+      ]);
+
+      // Create document first
+      await serverDB.insert(documents).values([
+        {
+          id: 'docs_test789',
+          title: 'Test Document',
+          content: 'Test content',
+          fileType: 'application/pdf',
+          totalCharCount: 100,
+          totalLineCount: 10,
+          sourceType: 'file',
+          source: 'test.pdf',
+          userId,
+        },
+      ]);
+
+      // Create mirror file with parentId pointing to the document
+      await serverDB.insert(files).values([
+        {
+          id: 'file1',
+          name: 'document.pdf',
+          url: 'https://example.com/document.pdf',
+          fileHash: 'hash1',
+          size: 1000,
+          fileType: 'application/pdf',
+          parentId: 'docs_test789', // Mirror file points to document
+          userId,
+        },
+      ]);
+
+      const { id: knowledgeBaseId } = await knowledgeBaseModel.create({ name: 'Test Group' });
+      await knowledgeBaseModel.addFilesToKnowledgeBase(knowledgeBaseId, ['docs_test789']);
+
+      // Remove using document ID
+      await knowledgeBaseModel.removeFilesFromKnowledgeBase(knowledgeBaseId, ['docs_test789']);
+
+      const remainingFiles = await serverDB.query.knowledgeBaseFiles.findMany({
+        where: eq(knowledgeBaseFiles.knowledgeBaseId, knowledgeBaseId),
+      });
+      expect(remainingFiles).toHaveLength(0);
+
+      // Verify document.knowledgeBaseId was cleared
+      const document = await serverDB.query.documents.findFirst({
+        where: eq(documents.id, 'docs_test789'),
+      });
+      expect(document?.knowledgeBaseId).toBeNull();
+    });
+
     it('should not allow removing files from another user knowledge base', async () => {
       await serverDB.insert(globalFiles).values([
         {

package/packages/database/src/models/knowledgeBase.ts

@@ -1,7 +1,7 @@
 import { KnowledgeBaseItem } from '@lobechat/types';
 import { and, desc, eq, inArray } from 'drizzle-orm';
 
-import { NewKnowledgeBase, knowledgeBaseFiles, knowledgeBases } from '../schemas';
+import { NewKnowledgeBase, documents, files, knowledgeBaseFiles, knowledgeBases } from '../schemas';
 import { LobeChatDatabase } from '../type';
 
 export class KnowledgeBaseModel {
@@ -25,9 +25,39 @@ export class KnowledgeBaseModel {
   };
 
   addFilesToKnowledgeBase = async (id: string, fileIds: string[]) => {
+    // Separate document IDs from file IDs
+    const documentIds = fileIds.filter((id) => id.startsWith('docs_'));
+    const directFileIds = fileIds.filter((id) => !id.startsWith('docs_'));
+
+    // Resolve document IDs to their mirror file IDs
+    // For Pages, files.parentId points to the document ID
+    let resolvedFileIds = [...directFileIds];
+    if (documentIds.length > 0) {
+      const mirrorFiles = await this.db
+        .select({ id: files.id })
+        .from(files)
+        .where(and(inArray(files.parentId, documentIds), eq(files.userId, this.userId)));
+
+      const mirrorFileIds = mirrorFiles.map((file) => file.id);
+      resolvedFileIds = [...resolvedFileIds, ...mirrorFileIds];
+
+      // Update documents.knowledgeBaseId for pages
+      await this.db
+        .update(documents)
+        .set({ knowledgeBaseId: id })
+        .where(and(inArray(documents.id, documentIds), eq(documents.userId, this.userId)));
+    }
+
+    // Insert using resolved file IDs
+    if (resolvedFileIds.length === 0) {
+      return [];
+    }
+
     return this.db
       .insert(knowledgeBaseFiles)
-      .values(fileIds.map((fileId) => ({ fileId, knowledgeBaseId: id, userId: this.userId })))
+      .values(
+        resolvedFileIds.map((fileId) => ({ fileId, knowledgeBaseId: id, userId: this.userId })),
+      )
       .returning();
   };
 
@@ -43,13 +73,47 @@ export class KnowledgeBaseModel {
   };
 
   removeFilesFromKnowledgeBase = async (knowledgeBaseId: string, ids: string[]) => {
+    // Separate document IDs from file IDs
+    const documentIds = ids.filter((id) => id.startsWith('docs_'));
+    const directFileIds = ids.filter((id) => !id.startsWith('docs_'));
+
+    // Resolve document IDs to their mirror file IDs
+    // For Pages, files.parentId points to the document ID
+    let resolvedFileIds = [...directFileIds];
+    if (documentIds.length > 0) {
+      const mirrorFiles = await this.db
+        .select({ id: files.id })
+        .from(files)
+        .where(and(inArray(files.parentId, documentIds), eq(files.userId, this.userId)));
+
+      const mirrorFileIds = mirrorFiles.map((file) => file.id);
+      resolvedFileIds = [...resolvedFileIds, ...mirrorFileIds];
+
+      // Clear documents.knowledgeBaseId for pages
+      await this.db
+        .update(documents)
+        .set({ knowledgeBaseId: null })
+        .where(
+          and(
+            inArray(documents.id, documentIds),
+            eq(documents.userId, this.userId),
+            eq(documents.knowledgeBaseId, knowledgeBaseId),
+          ),
+        );
+    }
+
+    // Delete using resolved file IDs
+    if (resolvedFileIds.length === 0) {
+      return;
+    }
+
     return this.db
       .delete(knowledgeBaseFiles)
       .where(
         and(
           eq(knowledgeBaseFiles.userId, this.userId),
           eq(knowledgeBaseFiles.knowledgeBaseId, knowledgeBaseId),
-          inArray(knowledgeBaseFiles.fileId, ids),
+          inArray(knowledgeBaseFiles.fileId, resolvedFileIds),
         ),
       );
   };

package/packages/database/src/repositories/agentGroup/index.test.ts

@@ -132,7 +132,7 @@ describe('AgentGroupRepository', () => {
 
       // Create group
       await serverDB.insert(chatGroups).values({
-        config: { scene: 'casual' },
+        config: { allowDM: true },
         id: 'detail-group',
         title: 'Detail Group',
         userId,
@@ -201,9 +201,9 @@ describe('AgentGroupRepository', () => {
     it('should return group with config', async () => {
       await serverDB.insert(chatGroups).values({
         config: {
-          maxResponseInRow: 3,
-          responseOrder: 'sequential',
-          scene: 'productive',
+          allowDM: true,
+          openingMessage: 'Welcome!',
+          revealDM: false,
         },
         description: 'Group with config',
         id: 'config-group',
@@ -216,9 +216,9 @@ describe('AgentGroupRepository', () => {
 
       expect(result).not.toBeNull();
       expect(result!.config).toEqual({
-        maxResponseInRow: 3,
-        responseOrder: 'sequential',
-        scene: 'productive',
+        allowDM: true,
+        openingMessage: 'Welcome!',
+        revealDM: false,
       });
       expect(result!.pinned).toBe(true);
     });
@@ -274,9 +274,8 @@ describe('AgentGroupRepository', () => {
       // Create group without supervisor
       await serverDB.insert(chatGroups).values({
         config: {
-          orchestratorModel: 'gpt-4o',
-          orchestratorProvider: 'openai',
-          scene: 'casual',
+          allowDM: true,
+          revealDM: true,
         },
         id: 'no-supervisor-group',
         title: 'Group without Supervisor',
@@ -307,13 +306,11 @@ describe('AgentGroupRepository', () => {
       // Should have 2 agents: auto-created supervisor + regular agent
       expect(result!.agents).toHaveLength(2);
 
-      // Verify agents include auto-created supervisor with config from group
+      // Verify agents include auto-created supervisor
       expect(result!.agents).toEqual(
         expect.arrayContaining([
           expect.objectContaining({
             isSupervisor: true,
-            model: 'gpt-4o',
-            provider: 'openai',
             title: 'Supervisor',
             virtual: true,
           }),
@@ -422,9 +419,8 @@ describe('AgentGroupRepository', () => {
     it('should create group with supervisor agent', async () => {
       const result = await agentGroupRepo.createGroupWithSupervisor({
         config: {
-          orchestratorModel: 'gpt-4',
-          orchestratorProvider: 'openai',
-          scene: 'productive',
+          allowDM: true,
+          openingMessage: 'Hello team!',
         },
         title: 'New Group with Supervisor',
       });
@@ -435,7 +431,7 @@ describe('AgentGroupRepository', () => {
       expect(result.supervisorAgentId).toBeDefined();
       expect(result.agents).toEqual([expect.objectContaining({ role: 'supervisor' })]);
 
-      // Verify supervisor agent was created with correct config
+      // Verify supervisor agent was created
       const groupDetail = await agentGroupRepo.findByIdWithAgents(result.group.id);
       expect(groupDetail).toMatchObject({
         supervisorAgentId: result.supervisorAgentId,
@@ -444,8 +440,6 @@ describe('AgentGroupRepository', () => {
         expect.arrayContaining([
           expect.objectContaining({
             id: result.supervisorAgentId,
-            model: 'gpt-4',
-            provider: 'openai',
             title: 'Supervisor',
             virtual: true,
           }),
@@ -772,11 +766,11 @@ describe('AgentGroupRepository', () => {
       // Create source group with full config
       await serverDB.insert(chatGroups).values({
         config: {
-          maxResponseInRow: 5,
-          orchestratorModel: 'gpt-4o',
-          orchestratorProvider: 'openai',
-          responseOrder: 'sequential',
-          scene: 'productive',
+          allowDM: true,
+          openingMessage: 'Welcome!',
+          openingQuestions: ['How can I help?'],
+          revealDM: false,
+          systemPrompt: 'You are a helpful assistant.',
         },
         id: 'source-group',
         pinned: true,
@@ -819,11 +813,11 @@ describe('AgentGroupRepository', () => {
       expect(duplicatedGroup).toEqual(
         expect.objectContaining({
           config: {
-            maxResponseInRow: 5,
-            orchestratorModel: 'gpt-4o',
-            orchestratorProvider: 'openai',
-            responseOrder: 'sequential',
-            scene: 'productive',
+            allowDM: true,
+            openingMessage: 'Welcome!',
+            openingQuestions: ['How can I help?'],
+            revealDM: false,
+            systemPrompt: 'You are a helpful assistant.',
           },
           pinned: true,
           title: 'Source Group (Copy)',

package/packages/database/src/repositories/agentGroup/index.ts

@@ -13,7 +13,6 @@ import {
   chatGroupsAgents,
 } from '../../schemas';
 import { LobeChatDatabase } from '../../type';
-import { ChatGroupConfig } from '../../types/chatGroup';
 
 export interface SupervisorAgentConfig {
   model?: string;
@@ -106,14 +105,12 @@ export class AgentGroupRepository {
 
     // 4. If no supervisor exists, create a virtual supervisor agent
     if (!supervisorAgentId) {
-      const groupConfig = group.config as ChatGroupConfig | undefined;
-
       // Create supervisor agent (virtual agent)
       const [supervisorAgent] = await this.db
         .insert(agents)
         .values({
-          model: groupConfig?.orchestratorModel,
-          provider: groupConfig?.orchestratorProvider,
+          model: undefined,
+          provider: undefined,
           title: 'Supervisor',
           userId: this.userId,
           virtual: true,
@@ -163,14 +160,12 @@ export class AgentGroupRepository {
     agentMembers: string[] = [],
     supervisorConfig?: SupervisorAgentConfig,
   ): Promise<CreateGroupWithSupervisorResult> {
-    const groupConfig = groupParams.config as ChatGroupConfig | undefined;
-
     // 1. Create supervisor agent (virtual agent)
     const [supervisorAgent] = await this.db
       .insert(agents)
       .values({
-        model: supervisorConfig?.model ?? groupConfig?.orchestratorModel,
-        provider: supervisorConfig?.provider ?? groupConfig?.orchestratorProvider,
+        model: supervisorConfig?.model,
+        provider: supervisorConfig?.provider,
         title: supervisorConfig?.title ?? 'Supervisor',
         userId: this.userId,
         virtual: true,

package/packages/database/src/repositories/knowledge/index.ts

@@ -202,7 +202,7 @@ export class KnowledgeRepo {
       FROM ${documents}
       WHERE user_id = ${this.userId}
         AND source_type != ${'file'}
-        AND (metadata->>'knowledgeBaseId') IS NULL
+        AND knowledge_base_id IS NULL
     `;
 
     const combinedQuery = sql`
@@ -554,11 +554,11 @@ export class KnowledgeRepo {
       }
 
       // When in a knowledge base, return standalone documents (folders and notes without fileId)
-      // that have the knowledgeBaseId set in their metadata. Documents with fileId are already
+      // that have the knowledgeBaseId column set. Documents with fileId are already
       // returned by the file query via their linked file records.
       kbWhereConditions.push(
         sql`d.file_id IS NULL`,
-        sql`d.metadata->>'knowledgeBaseId' = ${knowledgeBaseId}`,
+        sql`d.knowledge_base_id = ${knowledgeBaseId}`,
       );
 
       return sql`

package/packages/database/src/schemas/chatGroup.ts

@@ -9,7 +9,6 @@ import {
   text,
   uniqueIndex,
 } from 'drizzle-orm/pg-core';
-import { createInsertSchema } from 'drizzle-zod';
 
 import type { ChatGroupConfig } from '../types/chatGroup';
 import { idGenerator } from '../utils/idGenerator';
@@ -31,6 +30,10 @@ export const chatGroups = pgTable(
       .notNull(),
     title: text('title'),
     description: text('description'),
+    avatar: text('avatar'),
+    backgroundColor: text('background_color'),
+    content: text('content'),
+    editorData: jsonb('editor_data').$type<Record<string, any>>(),
 
     config: jsonb('config').$type<ChatGroupConfig>(),
 
@@ -52,8 +55,6 @@ export const chatGroups = pgTable(
   ],
 );
 
-export const insertChatGroupSchema = createInsertSchema(chatGroups);
-
 export type NewChatGroup = typeof chatGroups.$inferInsert;
 export type ChatGroupItem = typeof chatGroups.$inferSelect;
 

package/packages/database/src/types/chatGroup.ts

@@ -1,14 +1,7 @@
 export interface ChatGroupConfig {
   allowDM?: boolean;
-  enableSupervisor?: boolean;
-  maxResponseInRow?: number;
   openingMessage?: string;
   openingQuestions?: string[];
-  orchestratorModel?: string;
-  orchestratorProvider?: string;
-  responseOrder?: 'sequential' | 'natural';
-  responseSpeed?: 'slow' | 'medium' | 'fast';
   revealDM?: boolean;
-  scene: 'casual' | 'productive';
   systemPrompt?: string;
 }

package/packages/types/src/agentGroup/index.ts

@@ -1,3 +1,5 @@
+import { z } from 'zod';
+
 import { AgentItem } from '../agent';
 import { TaskDetail, UIChatMessage } from '../message';
 import { ChatTopic } from '../topic';
@@ -8,23 +10,42 @@ export interface LobeChatGroupMetaConfig {
 }
 
 export interface LobeChatGroupChatConfig {
-  allowDM: boolean;
-  enableSupervisor: boolean;
-  maxResponseInRow: number;
+  allowDM?: boolean;
   openingMessage?: string;
   openingQuestions?: string[];
-  orchestratorModel: string;
-  orchestratorProvider: string;
-  responseOrder: 'sequential' | 'natural';
-  responseSpeed: 'slow' | 'medium' | 'fast';
-  revealDM: boolean;
-  scene: 'casual' | 'productive';
+  revealDM?: boolean;
   systemPrompt?: string;
 }
 
 // Database config type (flat structure)
 export type LobeChatGroupConfig = LobeChatGroupChatConfig;
 
+// Zod schema for ChatGroupConfig (database insert)
+export const ChatGroupConfigSchema = z.object({
+  allowDM: z.boolean().optional(),
+  openingMessage: z.string().optional(),
+  openingQuestions: z.array(z.string()).optional(),
+  revealDM: z.boolean().optional(),
+  systemPrompt: z.string().optional(),
+});
+
+// Zod schema for inserting ChatGroup
+export const InsertChatGroupSchema = z.object({
+  avatar: z.string().optional().nullable(),
+  backgroundColor: z.string().optional().nullable(),
+  clientId: z.string().optional().nullable(),
+  config: ChatGroupConfigSchema.optional().nullable(),
+  content: z.string().optional().nullable(),
+  description: z.string().optional().nullable(),
+  editorData: z.record(z.string(), z.any()).optional().nullable(),
+  groupId: z.string().optional().nullable(),
+  id: z.string().optional(),
+  pinned: z.boolean().optional().nullable(),
+  title: z.string().optional().nullable(),
+});
+
+export type InsertChatGroup = z.infer<typeof InsertChatGroupSchema>;
+
 // Full group type with nested structure for UI components
 export interface LobeChatGroupFullConfig {
   chat: LobeChatGroupChatConfig;