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

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.27](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.26...v2.0.0-next.27)
+
+<sup>Released on **2025-11-04**</sup>
+
+#### ♻ Code Refactoring
+
+- **misc**: Refactor services to a more clean structure.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **misc**: Refactor services to a more clean structure, closes [#10050](https://github.com/lobehub/lobe-chat/issues/10050) ([de61dfa](https://github.com/lobehub/lobe-chat/commit/de61dfa))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.26](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.25...v2.0.0-next.26)
 
 <sup>Released on **2025-11-04**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Refactor services to a more clean structure."
+      ]
+    },
+    "date": "2025-11-04",
+    "version": "2.0.0-next.27"
+  },
   {
     "children": {
       "improvements": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.26",
+  "version": "2.0.0-next.27",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/types/src/topic/topic.ts

@@ -51,3 +51,17 @@ export interface TopicRankItem {
   sessionId: string | null;
   title: string | null;
 }
+
+export interface CreateTopicParams {
+  favorite?: boolean;
+  groupId?: string | null;
+  messages?: string[];
+  sessionId?: string | null;
+  title: string;
+}
+
+export interface QueryTopicParams {
+  containerId?: string | null; // sessionId or groupId
+  current?: number;
+  pageSize?: number;
+}

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

@@ -128,7 +128,13 @@ export const topicRouter = router({
     }),
 
   searchTopics: topicProcedure
-    .input(z.object({ keywords: z.string(), sessionId: z.string().nullable().optional() }))
+    .input(
+      z.object({
+        groupId: z.string().nullable().optional(),
+        keywords: z.string(),
+        sessionId: z.string().nullable().optional(),
+      }),
+    )
     .query(async ({ input, ctx }) => {
       return ctx.topicModel.queryByKeyword(input.keywords, input.sessionId);
     }),

package/src/services/aiModel/index.test.ts

@@ -1,7 +1,7 @@
 import { testService } from '~test-utils';
 
-import { ServerService } from './server';
+import { AiModelService } from './index';
 
-describe('aiModelService', () => {
-  testService(ServerService);
+describe('AiModelService', () => {
+  testService(AiModelService);
 });

package/src/services/aiModel/index.ts

@@ -1,3 +1,57 @@
-import { ServerService } from './server';
+import {
+  AiModelSortMap,
+  AiProviderModelListItem,
+  CreateAiModelParams,
+  ToggleAiModelEnableParams,
+  UpdateAiModelParams,
+} from 'model-bank';
 
-export const aiModelService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+
+export class AiModelService {
+  createAiModel = async (params: CreateAiModelParams) => {
+    return lambdaClient.aiModel.createAiModel.mutate(params);
+  };
+
+  getAiProviderModelList = async (id: string): Promise<AiProviderModelListItem[]> => {
+    return lambdaClient.aiModel.getAiProviderModelList.query({ id });
+  };
+
+  getAiModelById = async (id: string) => {
+    return lambdaClient.aiModel.getAiModelById.query({ id });
+  };
+
+  toggleModelEnabled = async (params: ToggleAiModelEnableParams) => {
+    return lambdaClient.aiModel.toggleModelEnabled.mutate(params);
+  };
+
+  updateAiModel = async (id: string, providerId: string, value: UpdateAiModelParams) => {
+    return lambdaClient.aiModel.updateAiModel.mutate({ id, providerId, value });
+  };
+
+  batchUpdateAiModels = async (id: string, models: AiProviderModelListItem[]) => {
+    return lambdaClient.aiModel.batchUpdateAiModels.mutate({ id, models });
+  };
+
+  batchToggleAiModels = async (id: string, models: string[], enabled: boolean) => {
+    return lambdaClient.aiModel.batchToggleAiModels.mutate({ enabled, id, models });
+  };
+
+  clearModelsByProvider = async (providerId: string) => {
+    return lambdaClient.aiModel.clearModelsByProvider.mutate({ providerId });
+  };
+
+  clearRemoteModels = async (providerId: string) => {
+    return lambdaClient.aiModel.clearRemoteModels.mutate({ providerId });
+  };
+
+  updateAiModelOrder = async (providerId: string, items: AiModelSortMap[]) => {
+    return lambdaClient.aiModel.updateAiModelOrder.mutate({ providerId, sortMap: items });
+  };
+
+  deleteAiModel = async (params: { id: string; providerId: string }) => {
+    return lambdaClient.aiModel.removeAiModel.mutate(params);
+  };
+}
+
+export const aiModelService = new AiModelService();

package/src/services/aiProvider/index.test.ts

@@ -1,7 +1,7 @@
 import { testService } from '~test-utils';
 
-import { ServerService } from './server';
+import { AiProviderService } from './index';
 
 describe('aiProviderService', () => {
-  testService(ServerService);
+  testService(AiProviderService);
 });

package/src/services/aiProvider/index.ts

@@ -1,3 +1,49 @@
-import { ServerService } from './server';
+import {
+  AiProviderDetailItem,
+  AiProviderRuntimeState,
+  AiProviderSortMap,
+  CreateAiProviderParams,
+  UpdateAiProviderConfigParams,
+} from '@/types/aiProvider';
 
-export const aiProviderService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+
+export class AiProviderService {
+  createAiProvider = async (params: CreateAiProviderParams) => {
+    return lambdaClient.aiProvider.createAiProvider.mutate(params);
+  };
+
+  getAiProviderList = async () => {
+    return lambdaClient.aiProvider.getAiProviderList.query();
+  };
+
+  getAiProviderById = async (id: string): Promise<AiProviderDetailItem | undefined> => {
+    return lambdaClient.aiProvider.getAiProviderById.query({ id });
+  };
+
+  toggleProviderEnabled = async (id: string, enabled: boolean) => {
+    return lambdaClient.aiProvider.toggleProviderEnabled.mutate({ enabled, id });
+  };
+
+  updateAiProvider = async (id: string, value: any) => {
+    return lambdaClient.aiProvider.updateAiProvider.mutate({ id, value });
+  };
+
+  updateAiProviderConfig = async (id: string, value: UpdateAiProviderConfigParams) => {
+    return lambdaClient.aiProvider.updateAiProviderConfig.mutate({ id, value });
+  };
+
+  updateAiProviderOrder = async (items: AiProviderSortMap[]) => {
+    return lambdaClient.aiProvider.updateAiProviderOrder.mutate({ sortMap: items });
+  };
+
+  deleteAiProvider = async (id: string) => {
+    return lambdaClient.aiProvider.removeAiProvider.mutate({ id });
+  };
+
+  getAiProviderRuntimeState = async (isLogin?: boolean): Promise<AiProviderRuntimeState> => {
+    return lambdaClient.aiProvider.getAiProviderRuntimeState.query({ isLogin });
+  };
+}
+
+export const aiProviderService = new AiProviderService();

package/src/services/chatGroup/index.ts

@@ -1,3 +1,67 @@
-import { ServerService } from './server';
+import {
+  ChatGroupAgentItem,
+  ChatGroupItem,
+  NewChatGroup,
+  NewChatGroupAgent,
+} from '@/database/schemas';
+import { lambdaClient } from '@/libs/trpc/client';
 
-export const chatGroupService = new ServerService();
+class ChatGroupService {
+  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) => {
+    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[]) => {
+    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 });
+  };
+}
+
+export const chatGroupService = new ChatGroupService();

package/src/services/export/index.ts

@@ -1,3 +1,11 @@
-import { ServerService } from './server';
+import { ExportDatabaseData } from '@/types/export';
 
-export const exportService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+
+class ExportService {
+  exportData = async (): Promise<ExportDatabaseData> => {
+    return await lambdaClient.exporter.exportData.mutate();
+  };
+}
+
+export const exportService = new ExportService();

package/src/services/file/index.ts

@@ -1,3 +1,62 @@
-import { ServerService } from './server';
+import { lambdaClient } from '@/libs/trpc/client';
+import {
+  CheckFileHashResult,
+  FileItem,
+  QueryFileListParams,
+  QueryFileListSchemaType,
+  UploadFileParams,
+} from '@/types/files';
 
-export const fileService = new ServerService();
+interface CreateFileParams extends Omit<UploadFileParams, 'url'> {
+  knowledgeBaseId?: string;
+  url: string;
+}
+
+export class FileService {
+  createFile = async (
+    params: UploadFileParams,
+    knowledgeBaseId?: string,
+  ): Promise<{ id: string; url: string }> => {
+    return lambdaClient.file.createFile.mutate({ ...params, knowledgeBaseId } as CreateFileParams);
+  };
+
+  getFile = async (id: string): Promise<FileItem> => {
+    const item = await lambdaClient.file.findById.query({ id });
+
+    if (!item) {
+      throw new Error('file not found');
+    }
+
+    return { ...item, type: item.fileType };
+  };
+
+  removeFile = async (id: string): Promise<void> => {
+    await lambdaClient.file.removeFile.mutate({ id });
+  };
+
+  removeFiles = async (ids: string[]): Promise<void> => {
+    await lambdaClient.file.removeFiles.mutate({ ids });
+  };
+
+  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 = async (hash: string): Promise<CheckFileHashResult> => {
+    return lambdaClient.file.checkFileHash.mutate({ hash });
+  };
+
+  removeFileAsyncTask = async (id: string, type: 'embedding' | 'chunk') => {
+    return lambdaClient.file.removeFileAsyncTask.mutate({ id, type });
+  };
+}
+
+export const fileService = new FileService();

package/src/services/import/index.ts

@@ -1,3 +1,134 @@
-import { ServerService } from './server';
+import { DefaultErrorShape } from '@trpc/server/unstable-core-do-not-import';
 
-export const importService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+import { uploadService } from '@/services/upload';
+import { useUserStore } from '@/store/user';
+import { ImportPgDataStructure } from '@/types/export';
+import { ImporterEntryData, ImportStage, OnImportCallbacks } from '@/types/importer';
+import { UserSettings } from '@/types/user/settings';
+import { uuid } from '@/utils/uuid';
+
+class ImportService {
+  importSettings = async (settings: UserSettings): Promise<void> => {
+    await useUserStore.getState().importAppSettings(settings);
+  };
+
+  importData = async (data: ImporterEntryData, callbacks?: OnImportCallbacks): 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 =
+      (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 = async (
+    data: ImportPgDataStructure,
+    options?: {
+      callbacks?: OnImportCallbacks;
+      overwriteExisting?: boolean;
+    },
+  ): Promise<void> => {
+    const { callbacks } = options || {};
+
+    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);
+    }
+  };
+}
+
+export const importService = new ImportService();

package/src/services/message/index.ts

@@ -1,3 +1,177 @@
-import { ServerService } from './server';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  ChatMessageError,
+  ChatMessagePluginError,
+  ChatTranslate,
+  ChatTTS,
+  CreateMessageParams,
+  CreateMessageResult,
+  ModelRankItem,
+  UIChatMessage,
+  UpdateMessageParams,
+  UpdateMessageRAGParams,
+  UpdateMessageResult,
+} from '@lobechat/types';
+import type { HeatmapsProps } from '@lobehub/charts';
 
-export const messageService = new ServerService();
+import { INBOX_SESSION_ID } from '@/const/session';
+import { lambdaClient } from '@/libs/trpc/client';
+import { useUserStore } from '@/store/user';
+import { labPreferSelectors } from '@/store/user/selectors';
+
+export class MessageService {
+  createMessage = async ({ sessionId, ...params }: CreateMessageParams): Promise<string> => {
+    return lambdaClient.message.createMessage.mutate({
+      ...params,
+      sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
+    });
+  };
+
+  createNewMessage = async ({
+    sessionId,
+    ...params
+  }: CreateMessageParams): Promise<CreateMessageResult> => {
+    return lambdaClient.message.createNewMessage.mutate({
+      ...params,
+      sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
+    });
+  };
+
+  getMessages = async (
+    sessionId: string,
+    topicId?: string,
+    groupId?: string,
+  ): Promise<UIChatMessage[]> => {
+    // 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 = async (groupId: string, topicId?: string): Promise<UIChatMessage[]> => {
+    // 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 = async (params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number> => {
+    return lambdaClient.message.count.query(params);
+  };
+
+  countWords = async (params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number> => {
+    return lambdaClient.message.countWords.query(params);
+  };
+
+  rankModels = async (): Promise<ModelRankItem[]> => {
+    return lambdaClient.message.rankModels.query();
+  };
+
+  getHeatmaps = async (): Promise<HeatmapsProps['data']> => {
+    return lambdaClient.message.getHeatmaps.query();
+  };
+
+  updateMessageError = async (id: string, error: ChatMessageError) => {
+    return lambdaClient.message.update.mutate({ id, value: { error } });
+  };
+
+  updateMessagePluginArguments = async (id: string, value: string | Record<string, any>) => {
+    const args = typeof value === 'string' ? value : JSON.stringify(value);
+    return lambdaClient.message.updateMessagePlugin.mutate({ id, value: { arguments: args } });
+  };
+
+  updateMessage = async (
+    id: string,
+    value: Partial<UpdateMessageParams>,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.update.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      value,
+    });
+  };
+
+  updateMessageTranslate = async (id: string, translate: Partial<ChatTranslate> | false) => {
+    return lambdaClient.message.updateTranslate.mutate({ id, value: translate as ChatTranslate });
+  };
+
+  updateMessageTTS = async (id: string, tts: Partial<ChatTTS> | false) => {
+    return lambdaClient.message.updateTTS.mutate({ id, value: tts });
+  };
+
+  updateMessagePluginState = async (id: string, value: Record<string, any>) => {
+    return lambdaClient.message.updatePluginState.mutate({ id, value });
+  };
+
+  updateMessagePluginError = async (id: string, error: ChatMessagePluginError | null) => {
+    return lambdaClient.message.updatePluginError.mutate({ id, value: error as any });
+  };
+
+  updateMessageRAG = async (id: string, data: UpdateMessageRAGParams): Promise<void> => {
+    return lambdaClient.message.updateMessageRAG.mutate({ id, value: data });
+  };
+
+  removeMessage = async (id: string) => {
+    return lambdaClient.message.removeMessage.mutate({ id });
+  };
+
+  removeMessages = async (ids: string[]) => {
+    return lambdaClient.message.removeMessages.mutate({ ids });
+  };
+
+  removeMessagesByAssistant = async (sessionId: string, topicId?: string) => {
+    return lambdaClient.message.removeMessagesByAssistant.mutate({
+      sessionId: this.toDbSessionId(sessionId),
+      topicId,
+    });
+  };
+
+  removeMessagesByGroup = async (groupId: string, topicId?: string) => {
+    return lambdaClient.message.removeMessagesByGroup.mutate({
+      groupId,
+      topicId,
+    });
+  };
+
+  removeAllMessages = async () => {
+    return lambdaClient.message.removeAllMessages.mutate();
+  };
+
+  private toDbSessionId = (sessionId: string | undefined) => {
+    return sessionId === INBOX_SESSION_ID ? null : sessionId;
+  };
+
+  hasMessages = async (): Promise<boolean> => {
+    const number = await this.countMessages();
+    return number > 0;
+  };
+
+  messageCountToCheckTrace = async (): Promise<boolean> => {
+    const number = await this.countMessages();
+    return number >= 4;
+  };
+}
+
+export const messageService = new MessageService();