@lobehub/lobehub 2.0.0-next.26 → 2.0.0-next.28

package/src/services/chatGroup/server.ts

@@ -1,67 +0,0 @@
-import {
-  ChatGroupAgentItem,
-  ChatGroupItem,
-  NewChatGroup,
-  NewChatGroupAgent,
-} from '@/database/schemas';
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IChatGroupService } from './type';
-
-export class ServerService implements IChatGroupService {
-  createGroup(params: Omit<NewChatGroup, 'userId'>): Promise<ChatGroupItem> {
-    return lambdaClient.group.createGroup.mutate({
-      ...params,
-      config: params.config as any,
-    });
-  }
-
-  updateGroup(id: string, value: Partial<ChatGroupItem>): Promise<ChatGroupItem> {
-    return lambdaClient.group.updateGroup.mutate({
-      id,
-      value: {
-        ...value,
-        config: value.config as any,
-      },
-    });
-  }
-
-  deleteGroup(id: string): Promise<any> {
-    return lambdaClient.group.deleteGroup.mutate({ id });
-  }
-
-  getGroup(id: string): Promise<ChatGroupItem | undefined> {
-    return lambdaClient.group.getGroup.query({ id });
-  }
-
-  getGroups(): Promise<ChatGroupItem[]> {
-    return lambdaClient.group.getGroups.query();
-  }
-
-  addAgentsToGroup(groupId: string, agentIds: string[]): Promise<ChatGroupAgentItem[]> {
-    return lambdaClient.group.addAgentsToGroup.mutate({ agentIds, groupId });
-  }
-
-  removeAgentsFromGroup(groupId: string, agentIds: string[]): Promise<any> {
-    return lambdaClient.group.removeAgentsFromGroup.mutate({ agentIds, groupId });
-  }
-
-  updateAgentInGroup(
-    groupId: string,
-    agentId: string,
-    updates: Partial<Pick<NewChatGroupAgent, 'order' | 'role'>>,
-  ): Promise<ChatGroupAgentItem> {
-    return lambdaClient.group.updateAgentInGroup.mutate({
-      agentId,
-      groupId,
-      updates: {
-        order: updates.order === null ? undefined : updates.order,
-        role: updates.role === null ? undefined : updates.role,
-      },
-    });
-  }
-
-  getGroupAgents(groupId: string): Promise<ChatGroupAgentItem[]> {
-    return lambdaClient.group.getGroupAgents.query({ groupId });
-  }
-}

package/src/services/chatGroup/type.ts

@@ -1,22 +0,0 @@
-import {
-  ChatGroupAgentItem,
-  ChatGroupItem,
-  NewChatGroup,
-  NewChatGroupAgent,
-} from '@/database/schemas';
-
-export interface IChatGroupService {
-  addAgentsToGroup(groupId: string, agentIds: string[]): Promise<ChatGroupAgentItem[]>;
-  createGroup(params: Omit<NewChatGroup, 'userId'>): Promise<ChatGroupItem>;
-  deleteGroup(id: string): Promise<any>;
-  getGroup(id: string): Promise<ChatGroupItem | undefined>;
-  getGroupAgents(groupId: string): Promise<ChatGroupAgentItem[]>;
-  getGroups(): Promise<ChatGroupItem[]>;
-  removeAgentsFromGroup(groupId: string, agentIds: string[]): Promise<any>;
-  updateAgentInGroup(
-    groupId: string,
-    agentId: string,
-    updates: Partial<Pick<NewChatGroupAgent, 'order' | 'role'>>,
-  ): Promise<ChatGroupAgentItem>;
-  updateGroup(id: string, value: Partial<ChatGroupItem>): Promise<ChatGroupItem>;
-}

package/src/services/export/server.ts

@@ -1,9 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IExportService } from './type';
-
-export class ServerService implements IExportService {
-  exportData: IExportService['exportData'] = async () => {
-    return await lambdaClient.exporter.exportData.mutate();
-  };
-}

package/src/services/export/type.ts

@@ -1,5 +0,0 @@
-import { ExportDatabaseData } from '@/types/export';
-
-export interface IExportService {
-  exportData(): Promise<ExportDatabaseData>;
-}

package/src/services/file/server.ts

@@ -1,53 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-import { 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 {
-  createFile: IFileService['createFile'] = async (params, knowledgeBaseId) => {
-    return lambdaClient.file.createFile.mutate({ ...params, knowledgeBaseId } as CreateFileParams);
-  };
-
-  getFile: IFileService['getFile'] = async (id) => {
-    const item = await lambdaClient.file.findById.query({ id });
-
-    if (!item) {
-      throw new Error('file not found');
-    }
-
-    return { ...item, type: item.fileType };
-  };
-
-  removeFile: IFileService['removeFile'] = async (id) => {
-    await lambdaClient.file.removeFile.mutate({ id });
-  };
-
-  removeFiles: IFileService['removeFiles'] = async (ids) => {
-    await lambdaClient.file.removeFiles.mutate({ ids });
-  };
-
-  removeAllFiles: IFileService['removeAllFiles'] = async () => {
-    await lambdaClient.file.removeAllFiles.mutate();
-  };
-
-  getFiles = async (params: QueryFileListParams) => {
-    return lambdaClient.file.getFiles.query(params as QueryFileListSchemaType);
-  };
-
-  getFileItem = async (id: string) => {
-    return lambdaClient.file.getFileItemById.query({ id });
-  };
-
-  checkFileHash: IFileService['checkFileHash'] = async (hash) => {
-    return lambdaClient.file.checkFileHash.mutate({ hash });
-  };
-
-  removeFileAsyncTask = async (id: string, type: 'embedding' | 'chunk') => {
-    return lambdaClient.file.removeFileAsyncTask.mutate({ id, type });
-  };
-}

package/src/services/file/type.ts

@@ -1,13 +0,0 @@
-import { CheckFileHashResult, FileItem, UploadFileParams } from '@/types/files';
-
-export interface IFileService {
-  checkFileHash(hash: string): Promise<CheckFileHashResult>;
-  createFile(
-    file: UploadFileParams,
-    knowledgeBaseId?: string,
-  ): Promise<{ id: string; url: string }>;
-  getFile(id: string): Promise<FileItem>;
-  removeAllFiles(): Promise<any>;
-  removeFile(id: string): Promise<void>;
-  removeFiles(ids: string[]): Promise<void>;
-}

package/src/services/import/server.ts

@@ -1,133 +0,0 @@
-import { DefaultErrorShape } from '@trpc/server/unstable-core-do-not-import';
-
-import { lambdaClient } from '@/libs/trpc/client';
-import { uploadService } from '@/services/upload';
-import { useUserStore } from '@/store/user';
-import { ImportPgDataStructure } from '@/types/export';
-import { ImportStage, OnImportCallbacks } from '@/types/importer';
-import { uuid } from '@/utils/uuid';
-
-import { IImportService } from './type';
-
-export class ServerService implements IImportService {
-  importSettings: IImportService['importSettings'] = async (settings) => {
-    await useUserStore.getState().importAppSettings(settings);
-  };
-
-  importData: IImportService['importData'] = async (data, callbacks) => {
-    const handleError = (e: unknown) => {
-      callbacks?.onStageChange?.(ImportStage.Error);
-      const error = e as DefaultErrorShape;
-
-      callbacks?.onError?.({
-        code: error.data.code,
-        httpStatus: error.data.httpStatus,
-        message: error.message,
-        path: error.data.path,
-      });
-    };
-
-    const totalLength =
-      (data.messages?.length || 0) +
-      (data.sessionGroups?.length || 0) +
-      (data.sessions?.length || 0) +
-      (data.topics?.length || 0);
-
-    if (totalLength < 500) {
-      callbacks?.onStageChange?.(ImportStage.Importing);
-      const time = Date.now();
-      try {
-        const result = await lambdaClient.importer.importByPost.mutate({ data });
-        const duration = Date.now() - time;
-
-        callbacks?.onStageChange?.(ImportStage.Success);
-        callbacks?.onSuccess?.(result.results, duration);
-      } catch (e) {
-        handleError(e);
-      }
-
-      return;
-    }
-
-    await this.uploadData(data, { callbacks, handleError });
-  };
-
-  importPgData: IImportService['importPgData'] = async (
-    data: ImportPgDataStructure,
-    {
-      callbacks,
-    }: {
-      callbacks?: OnImportCallbacks;
-      overwriteExisting?: boolean;
-    } = {},
-  ): Promise<void> => {
-    const handleError = (e: unknown) => {
-      callbacks?.onStageChange?.(ImportStage.Error);
-      const error = e as DefaultErrorShape;
-
-      callbacks?.onError?.({
-        code: error.data.code,
-        httpStatus: error.data.httpStatus,
-        message: error.message,
-        path: error.data.path,
-      });
-    };
-
-    const totalLength = Object.values(data.data)
-      .map((d) => d.length)
-      .reduce((a, b) => a + b, 0);
-
-    if (totalLength < 500) {
-      callbacks?.onStageChange?.(ImportStage.Importing);
-      const time = Date.now();
-      try {
-        const result = await lambdaClient.importer.importPgByPost.mutate(data);
-        const duration = Date.now() - time;
-
-        callbacks?.onStageChange?.(ImportStage.Success);
-        callbacks?.onSuccess?.(result.results, duration);
-      } catch (e) {
-        handleError(e);
-      }
-
-      return;
-    }
-
-    await this.uploadData(data, { callbacks, handleError });
-  };
-
-  private uploadData = async (
-    data: object,
-    { callbacks, handleError }: { callbacks?: OnImportCallbacks; handleError: (e: unknown) => any },
-  ) => {
-    // if the data is too large, upload it to S3 and upload by file
-    const filename = `${uuid()}.json`;
-
-    let pathname;
-    try {
-      callbacks?.onStageChange?.(ImportStage.Uploading);
-      const result = await uploadService.uploadDataToS3(data, {
-        filename,
-        onProgress: (status, state) => {
-          callbacks?.onFileUploading?.(state);
-        },
-        pathname: `import_config/${filename}`,
-      });
-      pathname = result.data.path;
-      console.log(pathname);
-    } catch {
-      throw new Error('Upload Error');
-    }
-
-    callbacks?.onStageChange?.(ImportStage.Importing);
-    const time = Date.now();
-    try {
-      const result = await lambdaClient.importer.importByFile.mutate({ pathname });
-      const duration = Date.now() - time;
-      callbacks?.onStageChange?.(ImportStage.Success);
-      callbacks?.onSuccess?.(result.results, duration);
-    } catch (e) {
-      handleError(e);
-    }
-  };
-}

package/src/services/import/type.ts

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

package/src/services/message/server.ts

@@ -1,151 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { ChatTranslate, UIChatMessage } from '@lobechat/types';
-
-import { INBOX_SESSION_ID } from '@/const/session';
-import { lambdaClient } from '@/libs/trpc/client';
-import { useUserStore } from '@/store/user';
-import { labPreferSelectors } from '@/store/user/selectors';
-
-import { IMessageService } from './type';
-
-export class ServerService implements IMessageService {
-  createMessage: IMessageService['createMessage'] = async ({ sessionId, ...params }) => {
-    return lambdaClient.message.createMessage.mutate({
-      ...params,
-      sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
-    });
-  };
-
-  createNewMessage: IMessageService['createNewMessage'] = async ({ sessionId, ...params }) => {
-    return lambdaClient.message.createNewMessage.mutate({
-      ...params,
-      sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
-    });
-  };
-
-  getMessages: IMessageService['getMessages'] = async (sessionId, topicId, groupId) => {
-    // Get user lab preference for message grouping
-    const useGroup = labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
-
-    const data = await lambdaClient.message.getMessages.query({
-      groupId,
-      sessionId: this.toDbSessionId(sessionId),
-      topicId,
-      useGroup,
-    });
-
-    return data as unknown as UIChatMessage[];
-  };
-
-  getGroupMessages: IMessageService['getGroupMessages'] = async (groupId, topicId) => {
-    // Get user lab preference for message grouping
-    const useGroup = labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
-
-    const data = await lambdaClient.message.getMessages.query({
-      groupId,
-      topicId,
-      useGroup,
-    });
-    return data as unknown as UIChatMessage[];
-  };
-
-  countMessages: IMessageService['countMessages'] = async (params) => {
-    return lambdaClient.message.count.query(params);
-  };
-
-  countWords: IMessageService['countWords'] = async (params) => {
-    return lambdaClient.message.countWords.query(params);
-  };
-
-  rankModels: IMessageService['rankModels'] = async () => {
-    return lambdaClient.message.rankModels.query();
-  };
-
-  getHeatmaps: IMessageService['getHeatmaps'] = async () => {
-    return lambdaClient.message.getHeatmaps.query();
-  };
-
-  updateMessageError: IMessageService['updateMessageError'] = async (id, error) => {
-    return lambdaClient.message.update.mutate({ id, value: { error } });
-  };
-
-  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: IMessageService['updateMessage'] = async (id, value, options) => {
-    return lambdaClient.message.update.mutate({
-      id,
-      sessionId: options?.sessionId,
-      topicId: options?.topicId,
-      value,
-    });
-  };
-
-  updateMessageTranslate: IMessageService['updateMessageTranslate'] = async (id, translate) => {
-    return lambdaClient.message.updateTranslate.mutate({ id, value: translate as ChatTranslate });
-  };
-
-  updateMessageTTS: IMessageService['updateMessageTTS'] = async (id, tts) => {
-    return lambdaClient.message.updateTTS.mutate({ id, value: tts });
-  };
-
-  updateMessagePluginState: IMessageService['updateMessagePluginState'] = async (id, value) => {
-    return lambdaClient.message.updatePluginState.mutate({ id, value });
-  };
-
-  updateMessagePluginError: IMessageService['updateMessagePluginError'] = async (id, error) => {
-    return lambdaClient.message.updatePluginError.mutate({ id, value: error as any });
-  };
-
-  updateMessageRAG: IMessageService['updateMessageRAG'] = async (id, data) => {
-    return lambdaClient.message.updateMessageRAG.mutate({ id, value: data });
-  };
-
-  removeMessage: IMessageService['removeMessage'] = async (id) => {
-    return lambdaClient.message.removeMessage.mutate({ id });
-  };
-
-  removeMessages: IMessageService['removeMessages'] = async (ids) => {
-    return lambdaClient.message.removeMessages.mutate({ ids });
-  };
-
-  removeMessagesByAssistant: IMessageService['removeMessagesByAssistant'] = async (
-    sessionId,
-    topicId,
-  ) => {
-    return lambdaClient.message.removeMessagesByAssistant.mutate({
-      sessionId: this.toDbSessionId(sessionId),
-      topicId,
-    });
-  };
-
-  removeMessagesByGroup: IMessageService['removeMessagesByGroup'] = async (groupId, topicId) => {
-    return lambdaClient.message.removeMessagesByGroup.mutate({
-      groupId,
-      topicId,
-    });
-  };
-
-  removeAllMessages: IMessageService['removeAllMessages'] = async () => {
-    return lambdaClient.message.removeAllMessages.mutate();
-  };
-
-  private toDbSessionId = (sessionId: string | undefined) => {
-    return sessionId === INBOX_SESSION_ID ? null : sessionId;
-  };
-
-  hasMessages: IMessageService['hasMessages'] = async () => {
-    const number = await this.countMessages();
-    return number > 0;
-  };
-
-  messageCountToCheckTrace: IMessageService['messageCountToCheckTrace'] = async () => {
-    const number = await this.countMessages();
-    return number >= 4;
-  };
-}

package/src/services/message/type.ts

@@ -1,55 +0,0 @@
-import {
-  ChatMessageError,
-  ChatMessagePluginError,
-  ChatTTS,
-  ChatTranslate,
-  CreateMessageParams,
-  CreateMessageResult,
-  ModelRankItem,
-  UIChatMessage,
-  UpdateMessageParams,
-  UpdateMessageRAGParams,
-  UpdateMessageResult,
-} from '@lobechat/types';
-import type { HeatmapsProps } from '@lobehub/charts';
-
-/* eslint-disable typescript-sort-keys/interface */
-
-export interface IMessageService {
-  createMessage(data: CreateMessageParams): Promise<string>;
-  createNewMessage(data: CreateMessageParams): Promise<CreateMessageResult>;
-
-  getMessages(sessionId: string, topicId?: string, groupId?: string): Promise<UIChatMessage[]>;
-  getGroupMessages(groupId: string, topicId?: string): Promise<UIChatMessage[]>;
-  countMessages(params?: {
-    endDate?: string;
-    range?: [string, string];
-    startDate?: string;
-  }): Promise<number>;
-  countWords(params?: {
-    endDate?: string;
-    range?: [string, string];
-    startDate?: string;
-  }): Promise<number>;
-  rankModels(): Promise<ModelRankItem[]>;
-  getHeatmaps(): Promise<HeatmapsProps['data']>;
-  updateMessageError(id: string, error: ChatMessageError): Promise<any>;
-  updateMessage(
-    id: string,
-    message: Partial<UpdateMessageParams>,
-    options?: { sessionId?: string | null; topicId?: string | null },
-  ): Promise<UpdateMessageResult>;
-  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>;
-  updateMessagePluginError(id: string, value: ChatMessagePluginError | null): Promise<any>;
-  updateMessageRAG(id: string, value: UpdateMessageRAGParams): Promise<void>;
-  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>;
-  removeMessagesByGroup(groupId: string, topicId?: string): Promise<any>;
-  removeAllMessages(): Promise<any>;
-  messageCountToCheckTrace(): Promise<boolean>;
-  hasMessages(): Promise<boolean>;
-}

package/src/services/plugin/server.ts

@@ -1,42 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IPluginService } from './type';
-
-export class ServerService implements IPluginService {
-  installPlugin: IPluginService['installPlugin'] = async (plugin) => {
-    await lambdaClient.plugin.createOrInstallPlugin.mutate(plugin);
-  };
-
-  getInstalledPlugins: IPluginService['getInstalledPlugins'] = () => {
-    return lambdaClient.plugin.getPlugins.query();
-  };
-
-  uninstallPlugin: IPluginService['uninstallPlugin'] = async (identifier) => {
-    await lambdaClient.plugin.removePlugin.mutate({ id: identifier });
-  };
-
-  createCustomPlugin: IPluginService['createCustomPlugin'] = async (customPlugin) => {
-    await lambdaClient.plugin.createPlugin.mutate({ ...customPlugin, type: 'customPlugin' });
-  };
-
-  updatePlugin: IPluginService['updatePlugin'] = async (id, value) => {
-    await lambdaClient.plugin.updatePlugin.mutate({
-      customParams: value.customParams,
-      id,
-      manifest: value.manifest,
-      settings: value.settings,
-    });
-  };
-
-  updatePluginManifest: IPluginService['updatePluginManifest'] = async (id, manifest) => {
-    await lambdaClient.plugin.updatePlugin.mutate({ id, manifest });
-  };
-
-  removeAllPlugins: IPluginService['removeAllPlugins'] = async () => {
-    await lambdaClient.plugin.removeAllPlugins.mutate();
-  };
-
-  updatePluginSettings: IPluginService['updatePluginSettings'] = async (id, settings, signal) => {
-    await lambdaClient.plugin.updatePlugin.mutate({ id, settings }, { signal });
-  };
-}

package/src/services/plugin/type.ts

@@ -1,23 +0,0 @@
-import { LobeTool } from '@lobechat/types';
-import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
-
-import { LobeToolCustomPlugin } from '@/types/tool/plugin';
-
-export interface InstallPluginParams {
-  customParams?: Record<string, any>;
-  identifier: string;
-  manifest: LobeChatPluginManifest;
-  settings?: Record<string, any>;
-  type: 'plugin' | 'customPlugin';
-}
-
-export interface IPluginService {
-  createCustomPlugin: (customPlugin: LobeToolCustomPlugin) => Promise<void>;
-  getInstalledPlugins: () => Promise<LobeTool[]>;
-  installPlugin: (plugin: InstallPluginParams) => Promise<void>;
-  removeAllPlugins: () => Promise<void>;
-  uninstallPlugin: (identifier: string) => Promise<void>;
-  updatePlugin: (id: string, value: Partial<LobeToolCustomPlugin>) => Promise<void>;
-  updatePluginManifest: (id: string, manifest: LobeChatPluginManifest) => Promise<void>;
-  updatePluginSettings: (id: string, settings: any, signal?: AbortSignal) => Promise<void>;
-}