@lobehub/chat 1.39.2 → 1.40.0

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

package/src/services/message/server.ts

@@ -1,30 +1,23 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { INBOX_SESSION_ID } from '@/const/session';
-import { MessageItem } from '@/database/schemas';
 import { lambdaClient } from '@/libs/trpc/client';
-import {
-  ChatMessage,
-  ChatMessageError,
-  ChatTTS,
-  ChatTranslate,
-  CreateMessageParams,
-} from '@/types/message';
+import { ChatMessage, ChatMessageError, ChatTranslate } from '@/types/message';
 
 import { IMessageService } from './type';
 
 export class ServerService implements IMessageService {
-  createMessage({ sessionId, ...params }: CreateMessageParams): Promise<string> {
+  createMessage: IMessageService['createMessage'] = async ({ sessionId, ...params }) => {
     return lambdaClient.message.createMessage.mutate({
       ...params,
       sessionId: this.toDbSessionId(sessionId),
     });
-  }
+  };
 
-  batchCreateMessages(messages: MessageItem[]): Promise<any> {
+  batchCreateMessages: IMessageService['batchCreateMessages'] = async (messages) => {
     return lambdaClient.message.batchCreateMessages.mutate(messages);
-  }
+  };
 
-  getMessages = async (sessionId?: string, topicId?: string | undefined) => {
+  getMessages: IMessageService['getMessages'] = async (sessionId, topicId) => {
     const data = await lambdaClient.message.getMessages.query({
       sessionId: this.toDbSessionId(sessionId),
       topicId,
@@ -33,85 +26,89 @@ export class ServerService implements IMessageService {
     return data as unknown as ChatMessage[];
   };
 
-  getAllMessages(): Promise<ChatMessage[]> {
+  getAllMessages: IMessageService['getAllMessages'] = async () => {
     return lambdaClient.message.getAllMessages.query();
-  }
+  };
 
-  getAllMessagesInSession(sessionId: string): Promise<ChatMessage[]> {
+  getAllMessagesInSession: IMessageService['getAllMessagesInSession'] = async (sessionId) => {
     return lambdaClient.message.getAllMessagesInSession.query({
       sessionId: this.toDbSessionId(sessionId),
     });
-  }
+  };
 
-  countMessages(): Promise<number> {
+  countMessages: IMessageService['countMessages'] = async () => {
     return lambdaClient.message.count.query();
-  }
-  countTodayMessages(): Promise<number> {
+  };
+
+  countTodayMessages: IMessageService['countTodayMessages'] = async () => {
     return lambdaClient.message.countToday.query();
-  }
+  };
 
-  updateMessageError(id: string, error: ChatMessageError): Promise<any> {
+  updateMessageError: IMessageService['updateMessageError'] = async (id, error) => {
     return lambdaClient.message.update.mutate({ id, value: { error } });
-  }
+  };
 
-  async updateMessagePluginError(id: string, error: ChatMessageError): Promise<any> {
+  updateMessagePluginError = async (id: string, error: ChatMessageError): Promise<any> => {
     return lambdaClient.message.update.mutate({ id, value: { pluginError: error } });
-  }
+  };
 
-  async updateMessagePluginArguments(
-    id: string,
-    value: string | Record<string, any>,
-  ): Promise<any> {
+  updateMessagePluginArguments: IMessageService['updateMessagePluginArguments'] = async (
+    id,
+    value,
+  ) => {
     const args = typeof value === 'string' ? value : JSON.stringify(value);
-
     return lambdaClient.message.updateMessagePlugin.mutate({ id, value: { arguments: args } });
-  }
+  };
 
-  updateMessage(id: string, message: Partial<MessageItem>): Promise<any> {
+  updateMessage: IMessageService['updateMessage'] = async (id, message) => {
     return lambdaClient.message.update.mutate({ id, value: message });
-  }
+  };
 
-  updateMessageTranslate(id: string, translate: Partial<ChatTranslate> | false): Promise<any> {
+  updateMessageTranslate: IMessageService['updateMessageTranslate'] = async (id, translate) => {
     return lambdaClient.message.updateTranslate.mutate({ id, value: translate as ChatTranslate });
-  }
+  };
 
-  updateMessageTTS(id: string, tts: Partial<ChatTTS> | false): Promise<any> {
+  updateMessageTTS: IMessageService['updateMessageTTS'] = async (id, tts) => {
     return lambdaClient.message.updateTTS.mutate({ id, value: tts });
-  }
+  };
 
-  updateMessagePluginState(id: string, value: any): Promise<any> {
+  updateMessagePluginState: IMessageService['updateMessagePluginState'] = async (id, value) => {
     return lambdaClient.message.updatePluginState.mutate({ id, value });
-  }
+  };
 
-  removeMessage(id: string): Promise<any> {
+  removeMessage: IMessageService['removeMessage'] = async (id) => {
     return lambdaClient.message.removeMessage.mutate({ id });
-  }
+  };
 
-  removeMessages(ids: string[]): Promise<any> {
+  removeMessages: IMessageService['removeMessages'] = async (ids) => {
     return lambdaClient.message.removeMessages.mutate({ ids });
-  }
+  };
 
-  removeMessagesByAssistant(sessionId: string, topicId?: string | undefined): Promise<any> {
+  removeMessagesByAssistant: IMessageService['removeMessagesByAssistant'] = async (
+    sessionId,
+    topicId,
+  ) => {
     return lambdaClient.message.removeMessagesByAssistant.mutate({
       sessionId: this.toDbSessionId(sessionId),
       topicId,
     });
-  }
-  removeAllMessages(): Promise<any> {
+  };
+
+  removeAllMessages: IMessageService['removeAllMessages'] = async () => {
     return lambdaClient.message.removeAllMessages.mutate();
-  }
+  };
 
-  private toDbSessionId(sessionId: string | undefined) {
+  private toDbSessionId = (sessionId: string | undefined) => {
     return sessionId === INBOX_SESSION_ID ? null : sessionId;
-  }
+  };
 
-  async hasMessages() {
+  hasMessages: IMessageService['hasMessages'] = async () => {
     const number = await this.countMessages();
     return number > 0;
-  }
+  };
 
-  async messageCountToCheckTrace() {
+  messageCountToCheckTrace: IMessageService['messageCountToCheckTrace'] = async () => {
     const number = await this.countMessages();
     return number >= 4;
-  }
+  };
 }

package/src/services/message/type.ts

@@ -24,11 +24,11 @@ export interface IMessageService {
   updateMessageTTS(id: string, tts: Partial<ChatTTS> | false): Promise<any>;
   updateMessageTranslate(id: string, translate: Partial<ChatTranslate> | false): Promise<any>;
   updateMessagePluginState(id: string, value: Record<string, any>): Promise<any>;
-
+  updateMessagePluginArguments(id: string, value: string | Record<string, any>): Promise<any>;
   removeMessage(id: string): Promise<any>;
   removeMessages(ids: string[]): Promise<any>;
   removeMessagesByAssistant(assistantId: string, topicId?: string): Promise<any>;
   removeAllMessages(): Promise<any>;
-
+  messageCountToCheckTrace(): Promise<boolean>;
   hasMessages(): Promise<boolean>;
 }

package/src/services/plugin/client.ts

@@ -1,51 +1,45 @@
-import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
-
 import { clientDB } from '@/database/client/db';
 import { PluginModel } from '@/database/server/models/plugin';
 import { BaseClientService } from '@/services/baseClientService';
 import { LobeTool } from '@/types/tool';
-import { LobeToolCustomPlugin } from '@/types/tool/plugin';
 
-import { IPluginService, InstallPluginParams } from './type';
+import { IPluginService } from './type';
 
 export class ClientService extends BaseClientService implements IPluginService {
   private get pluginModel(): PluginModel {
     return new PluginModel(clientDB as any, this.userId);
   }
 
-  installPlugin = async (plugin: InstallPluginParams) => {
+  installPlugin: IPluginService['installPlugin'] = async (plugin) => {
     await this.pluginModel.create(plugin);
-    return;
   };
 
-  getInstalledPlugins = () => {
+  getInstalledPlugins: IPluginService['getInstalledPlugins'] = () => {
     return this.pluginModel.query() as Promise<LobeTool[]>;
   };
 
-  async uninstallPlugin(identifier: string) {
+  uninstallPlugin: IPluginService['uninstallPlugin'] = async (identifier) => {
     await this.pluginModel.delete(identifier);
-    return;
-  }
+  };
 
-  async createCustomPlugin(customPlugin: LobeToolCustomPlugin) {
+  createCustomPlugin: IPluginService['createCustomPlugin'] = async (customPlugin) => {
     await this.pluginModel.create({ ...customPlugin, type: 'customPlugin' });
-    return;
-  }
+  };
 
-  async updatePlugin(id: string, value: LobeToolCustomPlugin) {
+  updatePlugin: IPluginService['updatePlugin'] = async (id, value) => {
     await this.pluginModel.update(id, value);
-    return;
-  }
-  async updatePluginManifest(id: string, manifest: LobeChatPluginManifest) {
+  };
+
+  updatePluginManifest: IPluginService['updatePluginManifest'] = async (id, manifest) => {
     await this.pluginModel.update(id, { manifest });
-  }
+  };
 
-  async removeAllPlugins() {
+  removeAllPlugins: IPluginService['removeAllPlugins'] = async () => {
     await this.pluginModel.deleteAll();
-  }
+  };
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async updatePluginSettings(id: string, settings: any, _?: AbortSignal) {
+  updatePluginSettings: IPluginService['updatePluginSettings'] = async (id, settings, _?) => {
     await this.pluginModel.update(id, { settings });
-  }
+  };
 }

package/src/services/plugin/server.ts

@@ -1,46 +1,42 @@
-import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
-
 import { lambdaClient } from '@/libs/trpc/client';
-import { LobeTool } from '@/types/tool';
-import { LobeToolCustomPlugin } from '@/types/tool/plugin';
 
-import { IPluginService, InstallPluginParams } from './type';
+import { IPluginService } from './type';
 
 export class ServerService implements IPluginService {
-  installPlugin = async (plugin: InstallPluginParams) => {
+  installPlugin: IPluginService['installPlugin'] = async (plugin) => {
     await lambdaClient.plugin.createOrInstallPlugin.mutate(plugin);
   };
 
-  getInstalledPlugins = (): Promise<LobeTool[]> => {
+  getInstalledPlugins: IPluginService['getInstalledPlugins'] = () => {
     return lambdaClient.plugin.getPlugins.query();
   };
 
-  async uninstallPlugin(identifier: string) {
+  uninstallPlugin: IPluginService['uninstallPlugin'] = async (identifier) => {
     await lambdaClient.plugin.removePlugin.mutate({ id: identifier });
-  }
+  };
 
-  async createCustomPlugin(customPlugin: LobeToolCustomPlugin) {
+  createCustomPlugin: IPluginService['createCustomPlugin'] = async (customPlugin) => {
     await lambdaClient.plugin.createPlugin.mutate({ ...customPlugin, type: 'customPlugin' });
-  }
+  };
 
-  async updatePlugin(id: string, value: LobeToolCustomPlugin) {
+  updatePlugin: IPluginService['updatePlugin'] = async (id, value) => {
     await lambdaClient.plugin.updatePlugin.mutate({
       customParams: value.customParams,
       id,
       manifest: value.manifest,
       settings: value.settings,
     });
-  }
+  };
 
-  async updatePluginManifest(id: string, manifest: LobeChatPluginManifest) {
+  updatePluginManifest: IPluginService['updatePluginManifest'] = async (id, manifest) => {
     await lambdaClient.plugin.updatePlugin.mutate({ id, manifest });
-  }
+  };
 
-  async removeAllPlugins() {
+  removeAllPlugins: IPluginService['removeAllPlugins'] = async () => {
     await lambdaClient.plugin.removeAllPlugins.mutate();
-  }
+  };
 
-  async updatePluginSettings(id: string, settings: any, signal?: AbortSignal) {
+  updatePluginSettings: IPluginService['updatePluginSettings'] = async (id, settings, signal) => {
     await lambdaClient.plugin.updatePlugin.mutate({ id, settings }, { signal });
-  }
+  };
 }

package/src/services/rag.ts

@@ -2,29 +2,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 });
-  }
+  createParseFileTask = async (id: string, skipExist?: boolean) => {
+    return lambdaClient.chunk.createParseFileTask.mutate({ id, skipExist });
+  };
 
-  async retryParseFile(id: string) {
-    return await lambdaClient.chunk.retryParseFileTask.mutate({ id });
-  }
+  retryParseFile = async (id: string) => {
+    return lambdaClient.chunk.retryParseFileTask.mutate({ id });
+  };
 
-  async createEmbeddingChunksTask(id: string) {
-    return await lambdaClient.chunk.createEmbeddingChunksTask.mutate({ id });
-  }
+  createEmbeddingChunksTask = async (id: string) => {
+    return lambdaClient.chunk.createEmbeddingChunksTask.mutate({ id });
+  };
 
-  async semanticSearch(query: string, fileIds?: string[]) {
-    return await lambdaClient.chunk.semanticSearch.mutate({ fileIds, query });
-  }
+  semanticSearch = async (query: string, fileIds?: string[]) => {
+    return lambdaClient.chunk.semanticSearch.mutate({ fileIds, query });
+  };
 
-  async semanticSearchForChat(params: SemanticSearchSchemaType) {
-    return await lambdaClient.chunk.semanticSearchForChat.mutate(params);
-  }
+  semanticSearchForChat = async (params: SemanticSearchSchemaType) => {
+    return lambdaClient.chunk.semanticSearchForChat.mutate(params);
+  };
 
-  async deleteMessageRagQuery(id: string) {
-    return await lambdaClient.message.removeMessageQuery.mutate({ id });
-  }
+  deleteMessageRagQuery = async (id: string) => {
+    return lambdaClient.message.removeMessageQuery.mutate({ id });
+  };
 }
 
 export const ragService = new RAGService();