@lobehub/chat 1.39.3 → 1.40.1

package/src/services/file/ClientS3/index.ts

@@ -17,21 +17,21 @@ export class BrowserS3Storage {
    * @param key 文件 hash
    * @param file File 对象
    */
-  async putObject(key: string, file: File): Promise<void> {
+  putObject = async (key: string, file: File): Promise<void> => {
     try {
       const data = await file.arrayBuffer();
       await set(key, { data, name: file.name, type: file.type }, this.store);
     } catch (e) {
       throw new Error(`Failed to put file ${file.name}: ${(e as Error).message}`);
     }
-  }
+  };
 
   /**
    * 获取文件
    * @param key 文件 hash
    * @returns File 对象
    */
-  async getObject(key: string): Promise<File | undefined> {
+  getObject = async (key: string): Promise<File | undefined> => {
     try {
       const res = await get<{ data: ArrayBuffer; name: string; type: string }>(key, this.store);
       if (!res) return;
@@ -40,19 +40,19 @@ export class BrowserS3Storage {
     } catch (e) {
       throw new Error(`Failed to get object (key=${key}): ${(e as Error).message}`);
     }
-  }
+  };
 
   /**
    * 删除文件
    * @param key 文件 hash
    */
-  async deleteObject(key: string): Promise<void> {
+  deleteObject = async (key: string): Promise<void> => {
     try {
       await del(key, this.store);
     } catch (e) {
       throw new Error(`Failed to delete object (key=${key}): ${(e as Error).message}`);
     }
-  }
+  };
 }
 
 export const clientS3Storage = new BrowserS3Storage();

package/src/services/file/client.ts

@@ -2,7 +2,6 @@ import { clientDB } from '@/database/client/db';
 import { FileModel } from '@/database/server/models/file';
 import { BaseClientService } from '@/services/baseClientService';
 import { clientS3Storage } from '@/services/file/ClientS3';
-import { FileItem, UploadFileParams } from '@/types/files';
 
 import { IFileService } from './type';
 
@@ -11,7 +10,7 @@ export class ClientService extends BaseClientService implements IFileService {
     return new FileModel(clientDB as any, this.userId);
   }
 
-  async createFile(file: UploadFileParams) {
+  createFile: IFileService['createFile'] = async (file) => {
     // save to local storage
     // we may want to save to a remote server later
     const res = await this.fileModel.create(
@@ -34,9 +33,9 @@ export class ClientService extends BaseClientService implements IFileService {
       id: res.id,
       url: `data:${file.fileType};base64,${base64}`,
     };
-  }
+  };
 
-  async getFile(id: string): Promise<FileItem> {
+  getFile: IFileService['getFile'] = async (id) => {
     const item = await this.fileModel.findById(id);
     if (!item) {
       throw new Error('file not found');
@@ -57,28 +56,28 @@ export class ClientService extends BaseClientService implements IFileService {
       updatedAt: new Date(item.updatedAt),
       url,
     };
-  }
+  };
 
-  async removeFile(id: string) {
+  removeFile: IFileService['removeFile'] = async (id) => {
     await this.fileModel.delete(id, false);
-  }
+  };
 
-  async removeFiles(ids: string[]) {
+  removeFiles: IFileService['removeFiles'] = async (ids) => {
     await this.fileModel.deleteMany(ids, false);
-  }
+  };
 
-  async removeAllFiles() {
+  removeAllFiles: IFileService['removeAllFiles'] = async () => {
     return this.fileModel.clear();
-  }
+  };
 
-  async checkFileHash(hash: string) {
+  checkFileHash: IFileService['checkFileHash'] = async (hash) => {
     return this.fileModel.checkHash(hash);
-  }
+  };
 
-  private async getBase64ByFileHash(hash: string) {
+  private getBase64ByFileHash = async (hash: string) => {
     const fileItem = await clientS3Storage.getObject(hash);
     if (!fileItem) throw new Error('file not found');
 
     return Buffer.from(await fileItem.arrayBuffer()).toString('base64');
-  }
+  };
 }

package/src/services/file/server.ts

@@ -1,10 +1,5 @@
 import { lambdaClient } from '@/libs/trpc/client';
-import {
-  FileItem,
-  QueryFileListParams,
-  QueryFileListSchemaType,
-  UploadFileParams,
-} from '@/types/files';
+import { QueryFileListParams, QueryFileListSchemaType, UploadFileParams } from '@/types/files';
 
 import { IFileService } from './type';
 
@@ -14,11 +9,11 @@ interface CreateFileParams extends Omit<UploadFileParams, 'url'> {
 }
 
 export class ServerService implements IFileService {
-  async createFile(params: UploadFileParams, knowledgeBaseId?: string) {
+  createFile: IFileService['createFile'] = async (params, knowledgeBaseId) => {
     return lambdaClient.file.createFile.mutate({ ...params, knowledgeBaseId } as CreateFileParams);
-  }
+  };
 
-  async getFile(id: string): Promise<FileItem> {
+  getFile: IFileService['getFile'] = async (id) => {
     const item = await lambdaClient.file.findById.query({ id });
 
     if (!item) {
@@ -26,33 +21,33 @@ export class ServerService implements IFileService {
     }
 
     return { ...item, type: item.fileType };
-  }
+  };
 
-  async removeFile(id: string) {
+  removeFile: IFileService['removeFile'] = async (id) => {
     await lambdaClient.file.removeFile.mutate({ id });
-  }
+  };
 
-  async removeFiles(ids: string[]) {
+  removeFiles: IFileService['removeFiles'] = async (ids) => {
     await lambdaClient.file.removeFiles.mutate({ ids });
-  }
+  };
 
-  async removeAllFiles() {
+  removeAllFiles: IFileService['removeAllFiles'] = async () => {
     await lambdaClient.file.removeAllFiles.mutate();
-  }
+  };
 
-  async getFiles(params: QueryFileListParams) {
+  getFiles = async (params: QueryFileListParams) => {
     return lambdaClient.file.getFiles.query(params as QueryFileListSchemaType);
-  }
+  };
 
-  async getFileItem(id: string) {
+  getFileItem = async (id: string) => {
     return lambdaClient.file.getFileItemById.query({ id });
-  }
+  };
 
-  async checkFileHash(hash: string) {
+  checkFileHash: IFileService['checkFileHash'] = async (hash) => {
     return lambdaClient.file.checkFileHash.mutate({ hash });
-  }
+  };
 
-  async removeFileAsyncTask(id: string, type: 'embedding' | 'chunk') {
-    return await lambdaClient.file.removeFileAsyncTask.mutate({ id, type });
-  }
+  removeFileAsyncTask = async (id: string, type: 'embedding' | 'chunk') => {
+    return lambdaClient.file.removeFileAsyncTask.mutate({ id, type });
+  };
 }

package/src/services/global.ts

@@ -4,7 +4,7 @@ import { edgeClient } from '@/libs/trpc/client';
 import { LobeAgentConfig } from '@/types/agent';
 import { GlobalServerConfig } from '@/types/serverConfig';
 
-const VERSION_URL = 'https://registry.npmmirror.com/@lobehub/chat';
+const VERSION_URL = 'https://registry.npmmirror.com/@lobehub/chat/latest';
 
 class GlobalService {
   /**
@@ -14,7 +14,7 @@ class GlobalService {
     const res = await fetch(VERSION_URL);
     const data = await res.json();
 
-    return data['dist-tags']?.latest;
+    return data['version'];
   };
 
   getGlobalConfig = async (): Promise<GlobalServerConfig> => {

package/src/services/import/client.ts

@@ -2,19 +2,20 @@ import { clientDB } from '@/database/client/db';
 import { DataImporterRepos } from '@/database/repositories/dataImporter';
 import { BaseClientService } from '@/services/baseClientService';
 import { useUserStore } from '@/store/user';
-import { ImportStage, ImporterEntryData, OnImportCallbacks } from '@/types/importer';
-import { UserSettings } from '@/types/user/settings';
+import { ImportStage } from '@/types/importer';
 
-export class ClientService extends BaseClientService {
+import { IImportService } from './type';
+
+export class ClientService extends BaseClientService implements IImportService {
   private get dataImporter(): DataImporterRepos {
     return new DataImporterRepos(clientDB as any, this.userId);
   }
 
-  importSettings = async (settings: UserSettings) => {
+  importSettings: IImportService['importSettings'] = async (settings) => {
     await useUserStore.getState().importAppSettings(settings);
   };
 
-  importData = async (data: ImporterEntryData, callbacks?: OnImportCallbacks) => {
+  importData: IImportService['importData'] = async (data, callbacks) => {
     callbacks?.onStageChange?.(ImportStage.Importing);
     const time = Date.now();
     try {

package/src/services/import/server.ts

@@ -2,16 +2,17 @@ import { DefaultErrorShape } from '@trpc/server/unstable-core-do-not-import';
 
 import { edgeClient, lambdaClient } from '@/libs/trpc/client';
 import { useUserStore } from '@/store/user';
-import { ImportStage, ImporterEntryData, OnImportCallbacks } from '@/types/importer';
-import { UserSettings } from '@/types/user/settings';
+import { ImportStage, OnImportCallbacks } from '@/types/importer';
 import { uuid } from '@/utils/uuid';
 
-export class ServerService {
-  importSettings = async (settings: UserSettings) => {
+import { IImportService } from './type';
+
+export class ServerService implements IImportService {
+  importSettings: IImportService['importSettings'] = async (settings) => {
     await useUserStore.getState().importAppSettings(settings);
   };
 
-  importData = async (data: ImporterEntryData, callbacks?: OnImportCallbacks): Promise<void> => {
+  importData: IImportService['importData'] = async (data, callbacks) => {
     const handleError = (e: unknown) => {
       callbacks?.onStageChange?.(ImportStage.Error);
       const error = e as DefaultErrorShape;

package/src/services/import/type.ts

@@ -0,0 +1,7 @@
+import { ImporterEntryData, OnImportCallbacks } from '@/types/importer';
+import { UserSettings } from '@/types/user/settings';
+
+export interface IImportService {
+  importData(data: ImporterEntryData, callbacks?: OnImportCallbacks): Promise<void>;
+  importSettings(settings: UserSettings): Promise<void>;
+}

package/src/services/knowledgeBase.ts

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

package/src/services/message/_deprecated.ts

@@ -118,4 +118,9 @@ export class ClientService implements IMessageService {
     const number = await this.countMessages();
     return number > 0;
   }
+
+  async messageCountToCheckTrace() {
+    const number = await this.countMessages();
+    return number >= 4;
+  }
 }

package/src/services/message/client.ts

@@ -2,17 +2,10 @@ import dayjs from 'dayjs';
 
 import { INBOX_SESSION_ID } from '@/const/session';
 import { clientDB } from '@/database/client/db';
-import { MessageItem } from '@/database/schemas';
 import { MessageModel } from '@/database/server/models/message';
 import { BaseClientService } from '@/services/baseClientService';
 import { clientS3Storage } from '@/services/file/ClientS3';
-import {
-  ChatMessage,
-  ChatMessageError,
-  ChatTTS,
-  ChatTranslate,
-  CreateMessageParams,
-} from '@/types/message';
+import { ChatMessage } from '@/types/message';
 
 import { IMessageService } from './type';
 
@@ -21,20 +14,20 @@ export class ClientService extends BaseClientService implements IMessageService
     return new MessageModel(clientDB as any, this.userId);
   }
 
-  async createMessage({ sessionId, ...params }: CreateMessageParams) {
+  createMessage: IMessageService['createMessage'] = async ({ sessionId, ...params }) => {
     const { id } = await this.messageModel.create({
       ...params,
       sessionId: this.toDbSessionId(sessionId) as string,
     });
 
     return id;
-  }
+  };
 
-  async batchCreateMessages(messages: MessageItem[]) {
+  batchCreateMessages: IMessageService['batchCreateMessages'] = async (messages) => {
     return this.messageModel.batchCreate(messages);
-  }
+  };
 
-  async getMessages(sessionId: string, topicId?: string) {
+  getMessages: IMessageService['getMessages'] = async (sessionId, topicId) => {
     const data = await this.messageModel.query(
       {
         sessionId: this.toDbSessionId(sessionId),
@@ -51,86 +44,97 @@ export class ClientService extends BaseClientService implements IMessageService
     );
 
     return data as unknown as ChatMessage[];
-  }
+  };
 
-  async getAllMessages() {
+  getAllMessages: IMessageService['getAllMessages'] = async () => {
     const data = await this.messageModel.queryAll();
 
     return data as unknown as ChatMessage[];
-  }
+  };
 
-  async countMessages() {
+  countMessages: IMessageService['countMessages'] = async () => {
     return this.messageModel.count();
-  }
+  };
 
-  async countTodayMessages() {
+  countTodayMessages: IMessageService['countTodayMessages'] = async () => {
     const topics = await this.messageModel.queryAll();
     return topics.filter(
       (item) => dayjs(item.createdAt).format('YYYY-MM-DD') === dayjs().format('YYYY-MM-DD'),
     ).length;
-  }
+  };
 
-  async getAllMessagesInSession(sessionId: string) {
+  getAllMessagesInSession: IMessageService['getAllMessagesInSession'] = async (sessionId) => {
     const data = this.messageModel.queryBySessionId(this.toDbSessionId(sessionId));
 
     return data as unknown as ChatMessage[];
-  }
+  };
 
-  async updateMessageError(id: string, error: ChatMessageError) {
+  updateMessageError: IMessageService['updateMessageError'] = async (id, error) => {
     return this.messageModel.update(id, { error });
-  }
+  };
 
-  async updateMessage(id: string, message: Partial<MessageItem>) {
+  updateMessage: IMessageService['updateMessage'] = async (id, message) => {
     return this.messageModel.update(id, message);
-  }
+  };
 
-  async updateMessageTTS(id: string, tts: Partial<ChatTTS> | false) {
+  updateMessageTTS: IMessageService['updateMessageTTS'] = async (id, tts) => {
     return this.messageModel.updateTTS(id, tts as any);
-  }
+  };
 
-  async updateMessageTranslate(id: string, translate: Partial<ChatTranslate> | false) {
+  updateMessageTranslate: IMessageService['updateMessageTranslate'] = async (id, translate) => {
     return this.messageModel.updateTranslate(id, translate as any);
-  }
+  };
 
-  async updateMessagePluginState(id: string, value: Record<string, any>) {
+  updateMessagePluginState: IMessageService['updateMessagePluginState'] = async (id, value) => {
     return this.messageModel.updatePluginState(id, value);
-  }
+  };
 
-  async updateMessagePluginArguments(id: string, value: string | Record<string, any>) {
+  updateMessagePluginArguments: IMessageService['updateMessagePluginArguments'] = async (
+    id,
+    value,
+  ) => {
     const args = typeof value === 'string' ? value : JSON.stringify(value);
 
     return this.messageModel.updateMessagePlugin(id, { arguments: args });
-  }
+  };
 
-  async removeMessage(id: string) {
+  removeMessage: IMessageService['removeMessage'] = async (id) => {
     return this.messageModel.deleteMessage(id);
-  }
+  };
 
-  async removeMessages(ids: string[]) {
+  removeMessages: IMessageService['removeMessages'] = async (ids) => {
     return this.messageModel.deleteMessages(ids);
-  }
+  };
 
-  async removeMessagesByAssistant(sessionId: string, topicId?: string) {
+  removeMessagesByAssistant: IMessageService['removeMessagesByAssistant'] = async (
+    sessionId,
+    topicId,
+  ) => {
     return this.messageModel.deleteMessagesBySession(this.toDbSessionId(sessionId), topicId);
-  }
+  };
 
-  async removeAllMessages() {
+  removeAllMessages: IMessageService['removeAllMessages'] = async () => {
     return this.messageModel.deleteAllMessages();
-  }
+  };
 
-  async hasMessages() {
+  hasMessages: IMessageService['hasMessages'] = async () => {
     const number = await this.countMessages();
     return number > 0;
-  }
+  };
+
+  messageCountToCheckTrace: IMessageService['messageCountToCheckTrace'] = async () => {
+    const number = await this.countMessages();
+    return number >= 4;
+  };
 
-  private toDbSessionId(sessionId: string | undefined) {
+  private toDbSessionId = (sessionId: string | undefined) => {
     return sessionId === INBOX_SESSION_ID ? undefined : sessionId;
-  }
+  };
 
-  private async getBase64ByFileHash(hash: string) {
+  private getBase64ByFileHash = async (hash: string) => {
     const fileItem = await clientS3Storage.getObject(hash);
     if (!fileItem) throw new Error('file not found');
 
     return Buffer.from(await fileItem.arrayBuffer()).toString('base64');
-  }
+  };
 }