@lobehub/chat 1.11.9 → 1.12.1

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

@@ -8,7 +8,7 @@ import { SessionModel } from '@/database/server/models/session';
 import { UserModel, UserNotFoundError } from '@/database/server/models/user';
 import { authedProcedure, router } from '@/libs/trpc';
 import { UserService } from '@/server/services/user';
-import { UserInitializationState, UserPreference } from '@/types/user';
+import { UserGuideSchema, UserInitializationState, UserPreference } from '@/types/user';
 
 const userProcedure = authedProcedure.use(async (opts) => {
   return opts.next({
@@ -84,6 +84,10 @@ export const userRouter = router({
     return ctx.userModel.deleteSetting(ctx.userId);
   }),
 
+  updateGuide: userProcedure.input(UserGuideSchema).mutation(async ({ ctx, input }) => {
+    return ctx.userModel.updateGuide(ctx.userId, input);
+  }),
+
   updatePreference: userProcedure.input(z.any()).mutation(async ({ ctx, input }) => {
     return ctx.userModel.updatePreference(ctx.userId, input);
   }),

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

@@ -0,0 +1,74 @@
+import { JWTPayload } from '@/const/auth';
+import { AsyncTaskModel } from '@/database/server/models/asyncTask';
+import { FileModel } from '@/database/server/models/file';
+import { ChunkContentParams, ContentChunk } from '@/server/modules/ContentChunk';
+import { createAsyncServerClient } from '@/server/routers/async';
+import { AsyncTaskStatus, AsyncTaskType } from '@/types/asyncTask';
+
+export class ChunkService {
+  private userId: string;
+  private chunkClient: ContentChunk;
+  private fileModel: FileModel;
+  private asyncTaskModel: AsyncTaskModel;
+
+  constructor(userId: string) {
+    this.userId = userId;
+
+    this.chunkClient = new ContentChunk();
+
+    this.fileModel = new FileModel(userId);
+    this.asyncTaskModel = new AsyncTaskModel(userId);
+  }
+
+  async chunkContent(params: ChunkContentParams) {
+    return this.chunkClient.chunkContent(params);
+  }
+
+  async asyncEmbeddingFileChunks(fileId: string, payload: JWTPayload) {
+    const result = await this.fileModel.findById(fileId);
+
+    if (!result) return;
+
+    // 1. create a asyncTaskId
+    const asyncTaskId = await this.asyncTaskModel.create({
+      status: AsyncTaskStatus.Pending,
+      type: AsyncTaskType.Embedding,
+    });
+
+    await this.fileModel.update(fileId, { embeddingTaskId: asyncTaskId });
+
+    const asyncCaller = await createAsyncServerClient(this.userId, payload);
+
+    // trigger embedding task asynchronously
+    await asyncCaller.file.embeddingChunks.mutate({ fileId, taskId: asyncTaskId });
+
+    return asyncTaskId;
+  }
+
+  /**
+   * parse file to chunks with async task
+   */
+  async asyncParseFileToChunks(fileId: string, payload: JWTPayload, skipExist?: boolean) {
+    const result = await this.fileModel.findById(fileId);
+
+    if (!result) return;
+
+    // skip if already exist chunk tasks
+    if (skipExist && result.chunkTaskId) return;
+
+    // 1. create a asyncTaskId
+    const asyncTaskId = await this.asyncTaskModel.create({
+      status: AsyncTaskStatus.Processing,
+      type: AsyncTaskType.Chunking,
+    });
+
+    await this.fileModel.update(fileId, { chunkTaskId: asyncTaskId });
+
+    const asyncCaller = await createAsyncServerClient(this.userId, payload);
+
+    // trigger parse file task asynchronously
+    asyncCaller.file.parseFileToChunks.mutate({ fileId: fileId, taskId: asyncTaskId });
+
+    return asyncTaskId;
+  }
+}

package/src/server/utils/files.ts

@@ -0,0 +1,9 @@
+import urlJoin from 'url-join';
+
+import { fileEnv } from '@/config/file';
+
+export const getFullFileUrl = (url?: string | null) => {
+  if (!url) return '';
+
+  return urlJoin(fileEnv.NEXT_PUBLIC_S3_DOMAIN!, url);
+};

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

@@ -129,25 +129,20 @@ describe('ChatService', () => {
     describe('should handle content correctly for vision models', () => {
       it('should include image content when with vision model', async () => {
         const messages = [
-          { content: 'Hello', role: 'user', files: ['file1'] }, // Message with files
-          { content: 'Hi', role: 'tool', plugin: { identifier: 'plugin1', apiName: 'api1' } }, // Message with tool role
-          { content: 'Hey', role: 'assistant' }, // Regular user message
-        ] as ChatMessage[];
-
-        // Mock file store state to return a specific image URL or Base64 for the given files
-        act(() => {
-          useFileStore.setState({
-            imagesMap: {
-              file1: {
+          {
+            content: 'Hello',
+            role: 'user',
+            imageList: [
+              {
                 id: 'file1',
-                name: 'abc.png',
-                saveMode: 'url',
-                fileType: 'image/png',
                 url: 'http://example.com/image.jpg',
+                alt: 'abc.png',
               },
-            },
-          });
-        });
+            ],
+          }, // Message with files
+          { content: 'Hi', role: 'tool', plugin: { identifier: 'plugin1', apiName: 'api1' } }, // Message with tool role
+          { content: 'Hey', role: 'assistant' }, // Regular user message
+        ] as ChatMessage[];
 
         const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
         await chatService.createAssistantMessage({
@@ -615,7 +610,7 @@ Get data from users`,
       const abortController = new AbortController();
       const trace = {};
 
-      const result = await chatService.fetchPresetTaskResult({
+      await chatService.fetchPresetTaskResult({
         params,
         onMessageHandle,
         onFinish,
@@ -625,9 +620,12 @@ Get data from users`,
         trace,
       });
 
-      expect(result).toBe('AI response');
-
-      expect(onFinish).toHaveBeenCalled();
+      expect(onFinish).toHaveBeenCalledWith('AI response', {
+        type: 'done',
+        observationId: null,
+        toolCalls: undefined,
+        traceId: null,
+      });
       expect(onError).not.toHaveBeenCalled();
       expect(onMessageHandle).toHaveBeenCalled();
       expect(onLoadingChange).toHaveBeenCalledWith(false); // 确认加载状态已经被设置为 false

package/src/services/__tests__/{upload.test.ts → upload_legacy.test.ts}

@@ -6,7 +6,7 @@ import { API_ENDPOINTS } from '@/services/_url';
 import { serverConfigSelectors } from '@/store/serverConfig/selectors';
 import { createServerConfigStore } from '@/store/serverConfig/store';
 
-import { uploadService } from '../upload';
+import { legacyUploadService as uploadService } from '../upload_legacy';
 
 vi.mock('@/store/serverConfig/selectors');
 vi.mock('@/libs/trpc/client', () => {

package/src/services/agent.ts

@@ -0,0 +1,45 @@
+import { lambdaClient } from '@/libs/trpc/client';
+
+class AgentService {
+  async createAgentKnowledgeBase(agentId: string, knowledgeBaseId: string, enabled?: boolean) {
+    return await lambdaClient.agent.createAgentKnowledgeBase.mutate({
+      agentId,
+      enabled,
+      knowledgeBaseId,
+    });
+  }
+
+  async deleteAgentKnowledgeBase(agentId: string, knowledgeBaseId: string) {
+    return await lambdaClient.agent.deleteAgentKnowledgeBase.mutate({ agentId, knowledgeBaseId });
+  }
+
+  async toggleKnowledgeBase(agentId: string, knowledgeBaseId: string, enabled?: boolean) {
+    return await lambdaClient.agent.toggleKnowledgeBase.mutate({
+      agentId,
+      enabled,
+      knowledgeBaseId,
+    });
+  }
+
+  async createAgentFiles(agentId: string, fileIds: string[], enabled?: boolean) {
+    return await lambdaClient.agent.createAgentFiles.mutate({ agentId, enabled, fileIds });
+  }
+
+  async deleteAgentFile(agentId: string, fileId: string) {
+    return await lambdaClient.agent.deleteAgentFile.mutate({ agentId, fileId });
+  }
+
+  async toggleFile(agentId: string, fileId: string, enabled?: boolean) {
+    return await lambdaClient.agent.toggleFile.mutate({
+      agentId,
+      enabled,
+      fileId,
+    });
+  }
+
+  async getFilesAndKnowledgeBases(agentId: string) {
+    return await lambdaClient.agent.getKnowledgeBasesAndFiles.query({ agentId });
+  }
+}
+
+export const agentService = new AgentService();

package/src/services/chat.ts

@@ -8,7 +8,6 @@ import { INBOX_SESSION_ID } from '@/const/session';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { TracePayload, TraceTagMap } from '@/const/trace';
 import { AgentRuntime, ChatCompletionErrorPayload, ModelProvider } from '@/libs/agent-runtime';
-import { filesSelectors, useFileStore } from '@/store/file';
 import { useSessionStore } from '@/store/session';
 import { sessionMetaSelectors } from '@/store/session/selectors';
 import { useToolStore } from '@/store/tool';
@@ -367,23 +366,26 @@ class ChatService {
         return;
       }
       onError?.(error, errorContent);
+      console.error(error);
     };
 
     onLoadingChange?.(true);
 
-    const data = await this.getChatCompletion(params, {
-      onErrorHandle: (error) => {
-        errorHandle(new Error(error.message), error);
-      },
-      onFinish,
-      onMessageHandle,
-      signal: abortController?.signal,
-      trace: this.mapTrace(trace, TraceTagMap.SystemChain),
-    }).catch(errorHandle);
+    try {
+      await this.getChatCompletion(params, {
+        onErrorHandle: (error) => {
+          errorHandle(new Error(error.message), error);
+        },
+        onFinish,
+        onMessageHandle,
+        signal: abortController?.signal,
+        trace: this.mapTrace(trace, TraceTagMap.SystemChain),
+      });
 
-    onLoadingChange?.(false);
-
-    return await data?.text();
+      onLoadingChange?.(false);
+    } catch (e) {
+      errorHandle(e as Error);
+    }
   };
 
   private processMessages = (
@@ -402,9 +404,9 @@ class ChatService {
     // for the models with visual ability, add image url to content
     // refs: https://platform.openai.com/docs/guides/vision/quick-start
     const getContent = (m: ChatMessage) => {
-      if (!m.files) return m.content;
+      if (!m.imageList) return m.content;
 
-      const imageList = filesSelectors.getImageUrlOrBase64ByList(m.files)(useFileStore.getState());
+      const imageList = m.imageList;
 
       if (imageList.length === 0) return m.content;
 

package/src/services/file/client.test.ts

@@ -58,7 +58,7 @@ describe('FileService', () => {
     const result = await fileService.createFile(localFile);
 
     expect(FileModel.create).toHaveBeenCalledWith(localFile);
-    expect(result).toEqual(localFile);
+    expect(result).toEqual({ url: 'data:image/png;base64,AA==' });
   });
 
   it('removeFile should delete the file from the database', async () => {
@@ -99,55 +99,6 @@ describe('FileService', () => {
       });
     });
 
-    it('should retrieve and convert URL file info to FilePreview when enableServer is true', async () => {
-      const fileId = '1';
-      const fileData: DB_File = {
-        name: 'test',
-        fileType: 'image/png',
-        saveMode: 'url',
-        metadata: {
-          filename: 'test.png',
-        },
-        size: 1,
-        url: '/test.png',
-      };
-
-      (FileModel.findById as Mock).mockResolvedValue(fileData);
-      vi.spyOn(serverConfigSelectors, 'enableUploadFileToServer').mockReturnValue(true);
-      s3Domain = 'https://example.com';
-
-      const result = await fileService.getFile(fileId);
-
-      expect(FileModel.findById).toHaveBeenCalledWith(fileId);
-      expect(result).toEqual({
-        fileType: 'image/png',
-        id: '1',
-        name: 'test.png',
-        saveMode: 'url',
-        url: 'https://example.com/test.png',
-      });
-    });
-
-    it('should throw an error when enableServer is true but NEXT_PUBLIC_S3_DOMAIN is not set', async () => {
-      const fileId = '1';
-      const fileData: DB_File = {
-        name: 'test',
-        fileType: 'image/png',
-        saveMode: 'url',
-        size: 1,
-        url: '/test.png',
-      };
-
-      (FileModel.findById as Mock).mockResolvedValue(fileData);
-      vi.spyOn(serverConfigSelectors, 'enableUploadFileToServer').mockReturnValue(true);
-
-      const getFilePromise = fileService.getFile(fileId);
-
-      await expect(getFilePromise).rejects.toThrow(
-        'fileEnv.NEXT_PUBLIC_S3_DOMAIN is not set while enable server upload',
-      );
-    });
-
     it('should throw an error when the file is not found', async () => {
       const fileId = 'non-existent';
       (FileModel.findById as Mock).mockResolvedValue(null);

package/src/services/file/client.ts

@@ -1,9 +1,5 @@
-import urlJoin from 'url-join';
-
-import { fileEnv } from '@/config/file';
 import { FileModel } from '@/database/client/models/file';
 import { DB_File } from '@/database/client/schemas/files';
-import { serverConfigSelectors } from '@/store/serverConfig/selectors';
 import { FilePreview } from '@/types/files';
 
 import { IFileService } from './type';
@@ -12,7 +8,14 @@ export class ClientService implements IFileService {
   async createFile(file: DB_File) {
     // save to local storage
     // we may want to save to a remote server later
-    return FileModel.create(file);
+    const res = await FileModel.create(file);
+    // arrayBuffer to url
+    const base64 = Buffer.from(file.data!).toString('base64');
+
+    return {
+      id: res.id,
+      url: `data:${file.fileType};base64,${base64}`,
+    };
   }
 
   async getFile(id: string): Promise<FilePreview> {
@@ -21,20 +24,6 @@ export class ClientService implements IFileService {
       throw new Error('file not found');
     }
 
-    if (item.saveMode === 'url') {
-      if (this.enableServer && !fileEnv.NEXT_PUBLIC_S3_DOMAIN) {
-        throw new Error('fileEnv.NEXT_PUBLIC_S3_DOMAIN is not set while enable server upload');
-      }
-
-      return {
-        fileType: item.fileType,
-        id,
-        name: item.metadata.filename,
-        saveMode: 'url',
-        url: urlJoin(fileEnv.NEXT_PUBLIC_S3_DOMAIN!, item.url!),
-      };
-    }
-
     // arrayBuffer to url
     const url = URL.createObjectURL(new Blob([item.data!], { type: item.fileType }));
     const base64 = Buffer.from(item.data!).toString('base64');
@@ -53,13 +42,11 @@ export class ClientService implements IFileService {
     return FileModel.delete(id);
   }
 
-  async removeAllFiles() {
-    return FileModel.clear();
+  async removeFiles(ids: string[]) {
+    await Promise.all(ids.map((id) => FileModel.delete(id)));
   }
 
-  private get enableServer() {
-    return serverConfigSelectors.enableUploadFileToServer(
-      window.global_serverConfigStore.getState(),
-    );
+  async removeAllFiles() {
+    return FileModel.clear();
   }
 }

package/src/services/file/server.ts

@@ -2,17 +2,23 @@ import urlJoin from 'url-join';
 
 import { fileEnv } from '@/config/file';
 import { lambdaClient } from '@/libs/trpc/client';
-import { FilePreview, UploadFileParams } from '@/types/files';
+import {
+  FilePreview,
+  QueryFileListParams,
+  QueryFileListSchemaType,
+  UploadFileParams,
+} from '@/types/files';
 
 import { IFileService } from './type';
 
 interface CreateFileParams extends Omit<UploadFileParams, 'url'> {
+  knowledgeBaseId?: string;
   url: string;
 }
 
 export class ServerService implements IFileService {
-  async createFile(params: UploadFileParams) {
-    return lambdaClient.file.createFile.mutate(params as CreateFileParams);
+  async createFile(params: UploadFileParams, knowledgeBaseId?: string) {
+    return lambdaClient.file.createFile.mutate({ ...params, knowledgeBaseId } as CreateFileParams);
   }
 
   async getFile(id: string): Promise<FilePreview> {
@@ -39,7 +45,23 @@ export class ServerService implements IFileService {
     await lambdaClient.file.removeFile.mutate({ id });
   }
 
+  async removeFiles(ids: string[]) {
+    await lambdaClient.file.removeFiles.mutate({ ids });
+  }
+
   async removeAllFiles() {
     await lambdaClient.file.removeAllFiles.mutate();
   }
+
+  async getFiles(params: QueryFileListParams) {
+    return lambdaClient.file.getFiles.query(params as QueryFileListSchemaType);
+  }
+
+  async getFileItem(id: string) {
+    return lambdaClient.file.getFileItemById.query({ id });
+  }
+
+  async checkFileHash(hash: string) {
+    return lambdaClient.file.checkFileHash.mutate({ hash });
+  }
 }

package/src/services/file/type.ts

@@ -1,9 +1,12 @@
-/* eslint-disable typescript-sort-keys/interface */
 import { FilePreview, UploadFileParams } from '@/types/files';
 
 export interface IFileService {
-  createFile(file: UploadFileParams): Promise<{ id: string }>;
-  removeFile(id: string): Promise<any>;
-  removeAllFiles(): Promise<any>;
+  createFile(
+    file: UploadFileParams,
+    knowledgeBaseId?: string,
+  ): Promise<{ id: string; url: string }>;
   getFile(id: string): Promise<FilePreview>;
+  removeAllFiles(): Promise<any>;
+  removeFile(id: string): Promise<any>;
+  removeFiles(ids: string[]): Promise<any>;
 }

package/src/services/knowledgeBase.ts

@@ -0,0 +1,34 @@
+import { lambdaClient } from '@/libs/trpc/client';
+import { CreateKnowledgeBaseParams } from '@/types/knowledgeBase';
+
+class KnowledgeBaseService {
+  async createKnowledgeBase(params: CreateKnowledgeBaseParams) {
+    return await lambdaClient.knowledgeBase.createKnowledgeBase.mutate(params);
+  }
+
+  async getKnowledgeBaseList() {
+    return await lambdaClient.knowledgeBase.getKnowledgeBases.query();
+  }
+
+  async getKnowledgeBaseById(id: string) {
+    return await lambdaClient.knowledgeBase.getKnowledgeBaseById.query({ id });
+  }
+
+  async updateKnowledgeBaseList(id: string, value: any) {
+    return await lambdaClient.knowledgeBase.updateKnowledgeBase.mutate({ id, value });
+  }
+
+  async deleteKnowledgeBase(id: string) {
+    return await lambdaClient.knowledgeBase.removeKnowledgeBase.mutate({ id });
+  }
+
+  async addFilesToKnowledgeBase(knowledgeBaseId: string, ids: string[]) {
+    return lambdaClient.knowledgeBase.addFilesToKnowledgeBase.mutate({ ids, knowledgeBaseId });
+  }
+
+  async removeFilesFromKnowledgeBase(knowledgeBaseId: string, ids: string[]) {
+    return lambdaClient.knowledgeBase.removeFilesFromKnowledgeBase.mutate({ ids, knowledgeBaseId });
+  }
+}
+
+export const knowledgeBaseService = new KnowledgeBaseService();

package/src/services/message/client.test.ts

@@ -127,7 +127,7 @@ describe('MessageClientService', () => {
 
       // Assert
       expect(MessageModel.query).toHaveBeenCalledWith({ sessionId, topicId });
-      expect(messages).toBe(mockMessages);
+      expect(messages).toEqual(mockMessages.map((i) => ({ ...i, imageList: [] })));
     });
   });
 

package/src/services/message/client.ts

@@ -1,10 +1,18 @@
 import dayjs from 'dayjs';
 
+import { FileModel } from '@/database/client/models/file';
 import { MessageModel } from '@/database/client/models/message';
 import { DB_Message } from '@/database/client/schemas/message';
-import { ChatMessage, ChatMessageError, ChatTTS, ChatTranslate } from '@/types/message';
+import {
+  ChatFileItem,
+  ChatMessage,
+  ChatMessageError,
+  ChatTTS,
+  ChatTranslate,
+  CreateMessageParams,
+} from '@/types/message';
 
-import { CreateMessageParams, IMessageService } from './type';
+import { IMessageService } from './type';
 
 export class ClientService implements IMessageService {
   async createMessage(data: CreateMessageParams) {
@@ -18,7 +26,25 @@ export class ClientService implements IMessageService {
   }
 
   async getMessages(sessionId: string, topicId?: string): Promise<ChatMessage[]> {
-    return MessageModel.query({ sessionId, topicId });
+    const messages = await MessageModel.query({ sessionId, topicId });
+
+    const fileList = (await Promise.all(
+      messages
+        .flatMap((item) => item.files)
+        .filter(Boolean)
+        .map(async (id) => FileModel.findById(id!)),
+    )) as ChatFileItem[];
+
+    return messages.map((item) => ({
+      ...item,
+      imageList: fileList
+        .filter((file) => item.files?.includes(file.id) && file.fileType.startsWith('image'))
+        .map((file) => ({
+          alt: file.name,
+          id: file.id,
+          url: file.url,
+        })),
+    }));
   }
 
   async getAllMessages() {

package/src/services/message/index.ts

@@ -3,6 +3,4 @@ import { isServerMode } from '@/const/version';
 import { ClientService } from './client';
 import { ServerService } from './server';
 
-export type { CreateMessageParams } from './type';
-
 export const messageService = isServerMode ? new ServerService() : new ClientService();

package/src/services/message/server.ts

@@ -1,9 +1,15 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { INBOX_SESSION_ID } from '@/const/session';
 import { lambdaClient } from '@/libs/trpc/client';
-import { ChatMessage, ChatMessageError, ChatTTS, ChatTranslate } from '@/types/message';
-
-import { CreateMessageParams, IMessageService } from './type';
+import {
+  ChatMessage,
+  ChatMessageError,
+  ChatTTS,
+  ChatTranslate,
+  CreateMessageParams,
+} from '@/types/message';
+
+import { IMessageService } from './type';
 
 export class ServerService implements IMessageService {
   createMessage({ sessionId, ...params }: CreateMessageParams): Promise<string> {

package/src/services/message/type.ts

@@ -4,23 +4,11 @@ import {
   ChatMessageError,
   ChatTTS,
   ChatTranslate,
-  MessageRoleType,
+  CreateMessageParams,
 } from '@/types/message';
 
 /* eslint-disable typescript-sort-keys/interface */
 
-export interface CreateMessageParams
-  extends Partial<Omit<ChatMessage, 'content' | 'role' | 'topicId'>> {
-  fromModel?: string;
-  fromProvider?: string;
-  sessionId: string;
-  traceId?: string;
-  topicId?: string;
-  content: string;
-  error?: ChatMessageError | null;
-  role: MessageRoleType;
-}
-
 export interface IMessageService {
   createMessage(data: CreateMessageParams): Promise<string>;
   batchCreateMessages(messages: ChatMessage[]): Promise<any>;

package/src/services/rag.ts

@@ -0,0 +1,29 @@
+import { lambdaClient } from '@/libs/trpc/client';
+import { SemanticSearchSchemaType } from '@/types/rag';
+
+class RAGService {
+  async createParseFileTask(id: string, skipExist?: boolean) {
+    return await lambdaClient.chunk.createParseFileTask.mutate({ id, skipExist });
+  }
+  async retryParseFile(id: string) {
+    return await lambdaClient.chunk.retryParseFileTask.mutate({ id });
+  }
+
+  async createEmbeddingChunksTask(id: string) {
+    return await lambdaClient.chunk.createEmbeddingChunksTask.mutate({ id });
+  }
+
+  async semanticSearch(query: string, fileIds?: string[]) {
+    return await lambdaClient.chunk.semanticSearch.mutate({ fileIds, query });
+  }
+
+  async semanticSearchForChat(params: SemanticSearchSchemaType) {
+    return await lambdaClient.chunk.semanticSearchForChat.mutate(params);
+  }
+
+  async deleteMessageRagQuery(id: string) {
+    return await lambdaClient.message.removeMessageQuery.mutate({ id });
+  }
+}
+
+export const ragService = new RAGService();

package/src/services/session/server.ts

@@ -68,7 +68,7 @@ export class ServerService implements ISessionService {
 
     // TODO: Need to be fixed
     // @ts-ignore
-    return lambdaClient.session.getSessionConfig.query({ id });
+    return lambdaClient.agent.getAgentConfig.query({ sessionId: id });
   }
 
   updateSessionConfig(