@lobehub/chat 1.39.3 → 1.40.0

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();

package/src/services/ragEval.ts

@@ -11,57 +11,60 @@ import {
 
 class RAGEvalService {
   // Dataset
-  async createDataset(params: CreateNewEvalDatasets): Promise<number | undefined> {
-    return await lambdaClient.ragEval.createDataset.mutate(params);
-  }
+  createDataset = async (params: CreateNewEvalDatasets): Promise<number | undefined> => {
+    return lambdaClient.ragEval.createDataset.mutate(params);
+  };
 
-  async getDatasets(knowledgeBaseId: string): Promise<RAGEvalDataSetItem[]> {
+  getDatasets = async (knowledgeBaseId: string): Promise<RAGEvalDataSetItem[]> => {
     return lambdaClient.ragEval.getDatasets.query({ knowledgeBaseId });
-  }
+  };
 
-  async removeDataset(id: number): Promise<void> {
+  removeDataset = async (id: number): Promise<void> => {
     await lambdaClient.ragEval.removeDataset.mutate({ id });
-  }
+  };
 
-  async updateDataset(id: number, value: Partial<typeof insertEvalDatasetsSchema>): Promise<void> {
+  updateDataset = async (
+    id: number,
+    value: Partial<typeof insertEvalDatasetsSchema>,
+  ): Promise<void> => {
     await lambdaClient.ragEval.updateDataset.mutate({ id, value });
-  }
+  };
 
   // Dataset Records
-  async getDatasetRecords(datasetId: number): Promise<EvalDatasetRecord[]> {
+  getDatasetRecords = async (datasetId: number): Promise<EvalDatasetRecord[]> => {
     return lambdaClient.ragEval.getDatasetRecords.query({ datasetId });
-  }
+  };
 
-  async removeDatasetRecord(id: number): Promise<void> {
+  removeDatasetRecord = async (id: number): Promise<void> => {
     await lambdaClient.ragEval.removeDatasetRecords.mutate({ id });
-  }
+  };
 
-  async importDatasetRecords(datasetId: number, file: File): Promise<void> {
+  importDatasetRecords = async (datasetId: number, file: File): Promise<void> => {
     const { path } = await uploadService.uploadWithProgress(file, { directory: 'ragEval' });
 
     await lambdaClient.ragEval.importDatasetRecords.mutate({ datasetId, pathname: path });
-  }
+  };
 
   // Evaluation
-  async createEvaluation(params: CreateNewEvalEvaluation): Promise<number | undefined> {
-    return await lambdaClient.ragEval.createEvaluation.mutate(params);
-  }
+  createEvaluation = async (params: CreateNewEvalEvaluation): Promise<number | undefined> => {
+    return lambdaClient.ragEval.createEvaluation.mutate(params);
+  };
 
-  async getEvaluationList(knowledgeBaseId: string): Promise<RAGEvalEvaluationItem[]> {
+  getEvaluationList = async (knowledgeBaseId: string): Promise<RAGEvalEvaluationItem[]> => {
     return lambdaClient.ragEval.getEvaluationList.query({ knowledgeBaseId });
-  }
+  };
 
-  async startEvaluationTask(id: number) {
+  startEvaluationTask = async (id: number) => {
     return lambdaClient.ragEval.startEvaluationTask.mutate({ id });
-  }
+  };
 
-  async removeEvaluation(id: number): Promise<void> {
+  removeEvaluation = async (id: number): Promise<void> => {
     await lambdaClient.ragEval.removeEvaluation.mutate({ id });
-  }
+  };
 
-  async checkEvaluationStatus(id: number): Promise<{ success: boolean }> {
+  checkEvaluationStatus = async (id: number): Promise<{ success: boolean }> => {
     return lambdaClient.ragEval.checkEvaluationStatus.query({ id });
-  }
+  };
 }
 
 export const ragEvalService = new RAGEvalService();

package/src/services/session/_deprecated.ts

@@ -75,7 +75,7 @@ export class ClientService implements ISessionService {
 
   async getAllAgents(): Promise<LobeSessions> {
     // TODO: add a filter to get only agents
-    return await SessionModel.query();
+    return SessionModel.query();
   }
 
   async countSessions() {
@@ -162,7 +162,7 @@ export class ClientService implements ISessionService {
   }
 
   async removeSessionGroup(id: string, removeChildren?: boolean) {
-    return await SessionGroupModel.delete(id, removeChildren);
+    return SessionGroupModel.delete(id, removeChildren);
   }
 
   async updateSessionGroup(id: string, data: Partial<SessionGroupItem>) {