@lobehub/lobehub 2.0.0-next.3 → 2.0.0-next.31

package/src/services/__tests__/tool.test.ts

@@ -1,8 +1,5 @@
 import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { edgeClient } from '@/libs/trpc/client';
-import { globalHelpers } from '@/store/global/helpers';
-
 import { toolService } from '../tool';
 import openAPIV3 from './openai/OpenAPI_V3.json';
 import OpenAIPlugin from './openai/plugin.json';

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

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

package/src/services/aiModel/index.ts

@@ -1,9 +1,57 @@
-import { isDesktop } from '@/const/version';
+import {
+  AiModelSortMap,
+  AiProviderModelListItem,
+  CreateAiModelParams,
+  ToggleAiModelEnableParams,
+  UpdateAiModelParams,
+} from 'model-bank';
 
-import { ClientService } from './client';
-import { ServerService } from './server';
+import { lambdaClient } from '@/libs/trpc/client';
 
-export const aiModelService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : new ClientService();
+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,10 +1,7 @@
 import { testService } from '~test-utils';
 
-import { ClientService } from './client';
-import { ServerService } from './server';
+import { AiProviderService } from './index';
 
 describe('aiProviderService', () => {
-  testService(ServerService);
-
-  testService(ClientService);
+  testService(AiProviderService);
 });

package/src/services/aiProvider/index.ts

@@ -1,9 +1,49 @@
-import { isDesktop } from '@/const/version';
+import {
+  AiProviderDetailItem,
+  AiProviderRuntimeState,
+  AiProviderSortMap,
+  CreateAiProviderParams,
+  UpdateAiProviderConfigParams,
+} from '@/types/aiProvider';
 
-import { ClientService } from './client';
-import { ServerService } from './server';
+import { lambdaClient } from '@/libs/trpc/client';
 
-export const aiProviderService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : new ClientService();
+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/chat/chat.test.ts

@@ -8,18 +8,12 @@ import { type Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vite
 
 import { DEFAULT_USER_AVATAR } from '@/const/meta';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
-import * as isCanUseFCModule from '@/helpers/isCanUseFC';
 import * as toolEngineeringModule from '@/helpers/toolEngineering';
-import { agentChatConfigSelectors, agentSelectors } from '@/store/agent/selectors';
+import { agentChatConfigSelectors } from '@/store/agent/selectors';
 import { aiModelSelectors } from '@/store/aiInfra';
 import { useToolStore } from '@/store/tool';
-import { toolSelectors } from '@/store/tool/selectors';
-import { modelProviderSelectors } from '@/store/user/selectors';
-import { DalleManifest } from '@/tools/dalle';
 import { WebBrowsingManifest } from '@/tools/web-browsing';
 
-import { API_ENDPOINTS } from '../_url';
-import * as helpers from './helper';
 import { chatService } from './index';
 
 // Mocking external dependencies
@@ -290,6 +284,9 @@ describe('ChatService', () => {
         vi.mocked(parseDataUri).mockReturnValue({ type: 'url', base64: null, mimeType: null });
         vi.mocked(isDesktopLocalStaticServerUrl).mockReturnValue(false); // Not a local URL
 
+        // Mock aiModelSelectors to return true for vision support
+        vi.spyOn(aiModelSelectors, 'isModelSupportVision').mockReturnValue(() => true);
+
         const messages = [
           {
             content: 'Hello',
@@ -375,6 +372,9 @@ describe('ChatService', () => {
           mimeType: 'image/png',
         });
 
+        // Mock aiModelSelectors to return true for vision support
+        vi.spyOn(aiModelSelectors, 'isModelSupportVision').mockReturnValue(() => true);
+
         const messages = [
           {
             content: 'Hello',
@@ -447,6 +447,9 @@ describe('ChatService', () => {
         vi.mocked(isDesktopLocalStaticServerUrl).mockReturnValue(false); // This is NOT a local URL
         vi.mocked(imageUrlToBase64).mockClear(); // Clear to ensure it's not called
 
+        // Mock aiModelSelectors to return true for vision support
+        vi.spyOn(aiModelSelectors, 'isModelSupportVision').mockReturnValue(() => true);
+
         const messages = [
           {
             content: 'Hello',
@@ -524,6 +527,9 @@ describe('ChatService', () => {
           mimeType: 'image/jpeg',
         });
 
+        // Mock aiModelSelectors to return true for vision support
+        vi.spyOn(aiModelSelectors, 'isModelSupportVision').mockReturnValue(() => true);
+
         const messages = [
           {
             content: 'Multiple images',
@@ -831,39 +837,6 @@ describe('ChatService', () => {
           undefined,
         );
       });
-
-      it('work with dalle3', async () => {
-        const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
-        const messages = [
-          {
-            role: 'user',
-            content: 'https://vercel.com/ 请分析 chatGPT 关键词\n\n',
-            sessionId: 'inbox',
-            createdAt: 1702723964330,
-            id: 'vyQvEw6V',
-            updatedAt: 1702723964330,
-            extra: {},
-            meta: {
-              avatar: DEFAULT_USER_AVATAR,
-            },
-          },
-        ] as UIChatMessage[];
-
-        await chatService.createAssistantMessage({
-          messages,
-          model: 'gpt-3.5-turbo-1106',
-          top_p: 1,
-          plugins: [DalleManifest.identifier],
-        });
-
-        // Assert that getChatCompletionSpy was called with the expected arguments
-        expect(getChatCompletionSpy).toHaveBeenCalled();
-
-        const calls = getChatCompletionSpy.mock.lastCall;
-        // Take a snapshot of the first call's first argument
-        expect(calls![0]).toMatchSnapshot();
-        expect(calls![1]).toBeUndefined();
-      });
     });
 
     describe('search functionality', () => {

package/src/services/chat/contextEngineering.test.ts

@@ -248,36 +248,6 @@ describe('contextEngineering', () => {
     ]);
   });
 
-  it('should inject INBOX_GUIDE_SYSTEM_ROLE for welcome questions in inbox session', async () => {
-    // Don't mock INBOX_GUIDE_SYSTEMROLE, use the real one
-    const messages: UIChatMessage[] = [
-      {
-        role: 'user',
-        content: 'Hello, this is my first question',
-        createdAt: Date.now(),
-        id: 'test-welcome',
-        meta: {},
-        updatedAt: Date.now(),
-      },
-    ];
-
-    const result = await contextEngineering({
-      messages,
-      model: 'gpt-4',
-      provider: 'openai',
-      isWelcomeQuestion: true,
-      sessionId: 'inbox',
-    });
-
-    // Should have system message with inbox guide content
-    const systemMessage = result.find((msg) => msg.role === 'system');
-    expect(systemMessage).toBeDefined();
-    // Check for characteristic content of the actual INBOX_GUIDE_SYSTEMROLE
-    expect(systemMessage!.content).toContain('LobeChat Support Assistant');
-    expect(systemMessage!.content).toContain('LobeHub');
-    expect(Object.keys(systemMessage!).length).toEqual(2);
-  });
-
   it('should inject historySummary into system message when provided', async () => {
     const historySummary = 'Previous conversation summary: User discussed AI topics.';
 

package/src/services/chat/contextEngineering.ts

@@ -1,9 +1,9 @@
-import { INBOX_GUIDE_SYSTEMROLE, INBOX_SESSION_ID, isDesktop, isServerMode } from '@lobechat/const';
+import { isDesktop, isServerMode } from '@lobechat/const';
 import {
   ContextEngine,
+  GroupMessageFlattenProcessor,
   HistorySummaryProvider,
   HistoryTruncateProcessor,
-  InboxGuideProvider,
   InputTemplateProcessor,
   MessageCleanupProcessor,
   MessageContentProcessor,
@@ -29,7 +29,6 @@ interface ContextEngineeringContext {
   historyCount?: number;
   historySummary?: string;
   inputTemplate?: string;
-  isWelcomeQuestion?: boolean;
   messages: UIChatMessage[];
   model: string;
   provider: string;
@@ -48,8 +47,6 @@ export const contextEngineering = async ({
   enableHistoryCount,
   historyCount,
   historySummary,
-  sessionId,
-  isWelcomeQuestion,
 }: ContextEngineeringContext): Promise<OpenAIChatMessage[]> => {
   const toolNameResolver = new ToolNameResolver();
 
@@ -63,14 +60,6 @@ export const contextEngineering = async ({
       // 2. System role injection (agent's system role)
       new SystemRoleInjector({ systemRole }),
 
-      // 3. Inbox guide system role injection
-      new InboxGuideProvider({
-        inboxGuideSystemRole: INBOX_GUIDE_SYSTEMROLE,
-        inboxSessionId: INBOX_SESSION_ID,
-        isWelcomeQuestion: isWelcomeQuestion,
-        sessionId: sessionId,
-      }),
-
       // 4. Tool system role injection
       new ToolSystemRoleProvider({
         getToolSystemRoles: (tools) => toolSelectors.enabledSystemRoles(tools)(getToolStoreState()),
@@ -89,14 +78,15 @@ export const contextEngineering = async ({
       // Create message processing processors
 
       // 6. Input template processing
-      new InputTemplateProcessor({
-        inputTemplate,
-      }),
+      new InputTemplateProcessor({ inputTemplate }),
 
       // 7. Placeholder variables processing
       new PlaceholderVariablesProcessor({ variableGenerators: VARIABLE_GENERATORS }),
 
-      // 8. Message content processing
+      // 8. Group message flatten (convert role=group to standard assistant + tool messages)
+      new GroupMessageFlattenProcessor(),
+
+      // 8.5 Message content processing
       new MessageContentProcessor({
         fileContext: { enabled: isServerMode, includeFileUrl: !isDesktop },
         isCanUseVideo,

package/src/services/chat/helper.ts

@@ -1,16 +1,9 @@
-import { isDeprecatedEdition } from '@lobechat/const';
 import { ModelProvider } from 'model-bank';
 
 import { getAiInfraStoreState } from '@/store/aiInfra';
 import { aiModelSelectors, aiProviderSelectors } from '@/store/aiInfra/selectors';
-import { getUserStoreState, useUserStore } from '@/store/user';
-import { modelConfigSelectors, modelProviderSelectors } from '@/store/user/selectors';
 
 export const isCanUseVision = (model: string, provider: string): boolean => {
-  // TODO: remove isDeprecatedEdition condition in V2.0
-  if (isDeprecatedEdition) {
-    return modelProviderSelectors.isModelEnabledVision(model)(getUserStoreState());
-  }
   return aiModelSelectors.isModelSupportVision(model, provider)(getAiInfraStoreState());
 };
 
@@ -24,40 +17,23 @@ export const isCanUseVideo = (model: string, provider: string): boolean => {
 export const findDeploymentName = (model: string, provider: string) => {
   let deploymentId = model;
 
-  // TODO: remove isDeprecatedEdition condition in V2.0
-  if (isDeprecatedEdition) {
-    const chatModelCards = modelProviderSelectors.getModelCardsById(ModelProvider.Azure)(
-      useUserStore.getState(),
-    );
-
-    const deploymentName = chatModelCards.find((i) => i.id === model)?.deploymentName;
-    if (deploymentName) deploymentId = deploymentName;
-  } else {
-    // find the model by id
-    const modelItem = getAiInfraStoreState().enabledAiModels?.find(
-      (i) => i.id === model && i.providerId === provider,
-    );
+  // find the model by id
+  const modelItem = getAiInfraStoreState().enabledAiModels?.find(
+    (i) => i.id === model && i.providerId === provider,
+  );
 
-    if (modelItem && modelItem.config?.deploymentName) {
-      deploymentId = modelItem.config?.deploymentName;
-    }
+  if (modelItem && modelItem.config?.deploymentName) {
+    deploymentId = modelItem.config?.deploymentName;
   }
 
   return deploymentId;
 };
 
 export const isEnableFetchOnClient = (provider: string) => {
-  // TODO: remove this condition in V2.0
-  if (isDeprecatedEdition) {
-    return modelConfigSelectors.isProviderFetchOnClient(provider)(useUserStore.getState());
-  } else {
-    return aiProviderSelectors.isProviderFetchOnClient(provider)(getAiInfraStoreState());
-  }
+  return aiProviderSelectors.isProviderFetchOnClient(provider)(getAiInfraStoreState());
 };
 
 export const resolveRuntimeProvider = (provider: string) => {
-  if (isDeprecatedEdition) return provider;
-
   const isBuiltin = Object.values(ModelProvider).includes(provider as any);
   if (isBuiltin) return provider;
 

package/src/services/chat/index.ts

@@ -52,12 +52,12 @@ interface FetchAITaskResultParams extends FetchSSEOptions {
   abortController?: AbortController;
   onError?: (e: Error, rawError?: any) => void;
   /**
-   * 加载状态变化处理函数
-   * @param loading - 是否处于加载状态
+   * Loading state change handler function
+   * @param loading - Whether in loading state
    */
   onLoadingChange?: (loading: boolean) => void;
   /**
-   * 请求对象
+   * Request object
    */
   params: ChatStreamInputParams;
   trace?: TracePayload;
@@ -66,7 +66,6 @@ interface FetchAITaskResultParams extends FetchSSEOptions {
 interface CreateAssistantMessageStream extends FetchSSEOptions {
   abortController?: AbortController;
   historySummary?: string;
-  isWelcomeQuestion?: boolean;
   params: GetChatCompletionPayload;
   trace?: TracePayload;
 }
@@ -113,9 +112,7 @@ class ChatService {
       enableHistoryCount: agentChatConfigSelectors.enableHistoryCount(agentStoreState),
       // include user messages
       historyCount: agentChatConfigSelectors.historyCount(agentStoreState) + 2,
-      historySummary: options?.historySummary,
       inputTemplate: chatConfig.inputTemplate,
-      isWelcomeQuestion: options?.isWelcomeQuestion,
       messages,
       model: payload.model,
       provider: payload.provider!,
@@ -217,12 +214,10 @@ class ChatService {
     onErrorHandle,
     onFinish,
     trace,
-    isWelcomeQuestion,
     historySummary,
   }: CreateAssistantMessageStream) => {
     await this.createAssistantMessage(params, {
       historySummary,
-      isWelcomeQuestion,
       onAbort,
       onErrorHandle,
       onFinish,
@@ -404,7 +399,7 @@ class ChatService {
     onLoadingChange?.(true);
 
     try {
-      const oaiMessages = await contextEngineering({
+      const llmMessages = await contextEngineering({
         messages: params.messages as any,
         model: params.model!,
         provider: params.provider!,
@@ -421,7 +416,7 @@ class ChatService {
       // remove plugins
       delete params.plugins;
       await this.getChatCompletion(
-        { ...params, messages: oaiMessages, tools },
+        { ...params, messages: llmMessages, tools },
         {
           onErrorHandle: (error) => {
             errorHandle(new Error(error.message), error);

package/src/services/chat/types.ts

@@ -1,9 +1,9 @@
 import { TracePayload } from '@lobechat/types';
+
 import { FetchSSEOptions } from '@/utils/fetch';
 
 export interface FetchOptions extends FetchSSEOptions {
   historySummary?: string;
-  isWelcomeQuestion?: boolean;
   signal?: AbortSignal | undefined;
   trace?: TracePayload;
 }

package/src/services/chatGroup/index.ts

@@ -1,12 +1,67 @@
-import { isDesktop } from '@/const/version';
+import {
+  ChatGroupAgentItem,
+  ChatGroupItem,
+  NewChatGroup,
+  NewChatGroupAgent,
+} from '@/database/schemas';
+import { lambdaClient } from '@/libs/trpc/client';
 
-import { ClientService } from './client';
-import { ServerService } from './server';
+class ChatGroupService {
+  createGroup = (params: Omit<NewChatGroup, 'userId'>): Promise<ChatGroupItem> => {
+    return lambdaClient.group.createGroup.mutate({
+      ...params,
+      config: params.config as any,
+    });
+  };
 
-const clientService =
-  process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new ServerService();
+  updateGroup = (id: string, value: Partial<ChatGroupItem>): Promise<ChatGroupItem> => {
+    return lambdaClient.group.updateGroup.mutate({
+      id,
+      value: {
+        ...value,
+        config: value.config as any,
+      },
+    });
+  };
 
-export const chatGroupService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : clientService;
+  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/config.ts

@@ -1,23 +1,13 @@
-import { BRANDING_NAME, isDeprecatedEdition, isServerMode } from '@lobechat/const';
+import { BRANDING_NAME, isServerMode } from '@lobechat/const';
 import { downloadFile, exportJSONFile } from '@lobechat/utils/client';
 import dayjs from 'dayjs';
 
-import { CURRENT_CONFIG_VERSION } from '@/migrations';
 import { ImportPgDataStructure } from '@/types/export';
 
 import { exportService } from './export';
-import { configService as deprecatedExportService } from './export/_deprecated';
 
 class ConfigService {
   exportAll = async () => {
-    // TODO: remove this in V2
-    if (isDeprecatedEdition) {
-      const config = await deprecatedExportService.exportAll();
-      const filename = `${BRANDING_NAME}-config-v${CURRENT_CONFIG_VERSION}.json`;
-      exportJSONFile(config, filename);
-      return;
-    }
-
     const { data, url } = await exportService.exportData();
     const filename = `${dayjs().format('YYYY-MM-DD-hh-mm')}_${BRANDING_NAME}-data.json`;
 
@@ -34,60 +24,6 @@ class ConfigService {
     exportJSONFile(result, filename);
   };
 
-  exportAgents = async () => {
-    // TODO: remove this in V2
-    if (isDeprecatedEdition) {
-      const config = await deprecatedExportService.exportAgents();
-      const filename = `${BRANDING_NAME}-agents-v${CURRENT_CONFIG_VERSION}.json`;
-      exportJSONFile(config, filename);
-      return;
-    }
-  };
-
-  exportSingleAgent = async (agentId: string) => {
-    // TODO: remove this in V2
-    if (isDeprecatedEdition) {
-      const result = await deprecatedExportService.exportSingleAgent(agentId);
-      if (!result) return;
-
-      const filename = `${BRANDING_NAME}-${result.title}-v${CURRENT_CONFIG_VERSION}.json`;
-      exportJSONFile(result.config, filename);
-      return;
-    }
-  };
-
-  exportSessions = async () => {
-    // TODO: remove this in V2
-    if (isDeprecatedEdition) {
-      const config = await deprecatedExportService.exportSessions();
-      const filename = `${BRANDING_NAME}-sessions-v${CURRENT_CONFIG_VERSION}.json`;
-      exportJSONFile(config, filename);
-      return;
-    }
-  };
-
-  exportSettings = async () => {
-    // TODO: remove this in V2
-    if (isDeprecatedEdition) {
-      const config = await deprecatedExportService.exportSessions();
-      const filename = `${BRANDING_NAME}-settings-v${CURRENT_CONFIG_VERSION}.json`;
-      exportJSONFile(config, filename);
-      return;
-    }
-  };
-
-  exportSingleSession = async (sessionId: string) => {
-    // TODO: remove this in V2
-    if (isDeprecatedEdition) {
-      const data = await deprecatedExportService.exportSingleSession(sessionId);
-      if (!data) return;
-
-      const filename = `${BRANDING_NAME}-${data.title}-v${CURRENT_CONFIG_VERSION}.json`;
-      exportJSONFile(data.config, filename);
-      return;
-    }
-  };
-
   private createDataStructure = async (
     data: any,
     mode: 'pglite' | 'postgres',

package/src/services/export/index.ts

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