@lobehub/chat 1.46.6 → 1.47.0

package/src/services/aiModel/client.ts

@@ -0,0 +1,60 @@
+import { clientDB } from '@/database/client/db';
+import { AiInfraRepos } from '@/database/repositories/aiInfra';
+import { AiModelModel } from '@/database/server/models/aiModel';
+import { BaseClientService } from '@/services/baseClientService';
+
+import { IAiModelService } from './type';
+
+export class ClientService extends BaseClientService implements IAiModelService {
+  private get aiModel(): AiModelModel {
+    return new AiModelModel(clientDB as any, this.userId);
+  }
+  private get aiInfraRepos(): AiInfraRepos {
+    return new AiInfraRepos(clientDB as any, this.userId, {});
+  }
+
+  createAiModel: IAiModelService['createAiModel'] = async (params) => {
+    const data = await this.aiModel.create(params);
+
+    return data?.id;
+  };
+
+  getAiProviderModelList: IAiModelService['getAiProviderModelList'] = async (id) => {
+    return this.aiInfraRepos.getAiProviderModelList(id);
+  };
+
+  getAiModelById: IAiModelService['getAiModelById'] = async (id) => {
+    return this.aiModel.findById(id);
+  };
+
+  toggleModelEnabled: IAiModelService['toggleModelEnabled'] = async (params) => {
+    return this.aiModel.toggleModelEnabled(params);
+  };
+
+  updateAiModel: IAiModelService['updateAiModel'] = async (id, providerId, value) => {
+    return this.aiModel.update(id, providerId, value);
+  };
+
+  batchUpdateAiModels: IAiModelService['batchUpdateAiModels'] = async (id, models) => {
+    return this.aiModel.batchUpdateAiModels(id, models);
+  };
+
+  batchToggleAiModels: IAiModelService['batchToggleAiModels'] = async (id, models, enabled) => {
+    return this.aiModel.batchToggleAiModels(id, models, enabled);
+  };
+
+  clearRemoteModels: IAiModelService['clearRemoteModels'] = async (providerId) => {
+    return this.aiModel.clearRemoteModels(providerId);
+  };
+
+  updateAiModelOrder: IAiModelService['updateAiModelOrder'] = async (providerId, items) => {
+    return this.aiModel.updateModelsOrder(providerId, items);
+  };
+
+  deleteAiModel: IAiModelService['deleteAiModel'] = async (params: {
+    id: string;
+    providerId: string;
+  }) => {
+    return this.aiModel.delete(params.id, params.providerId);
+  };
+}

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

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

package/src/services/aiModel/index.ts

@@ -0,0 +1,5 @@
+import { ClientService } from './client';
+import { ServerService } from './server';
+
+export const aiModelService =
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : new ClientService();

package/src/services/aiModel/server.ts

@@ -0,0 +1,47 @@
+import { lambdaClient } from '@/libs/trpc/client';
+import { IAiModelService } from '@/services/aiModel/type';
+
+export class ServerService implements IAiModelService {
+  createAiModel: IAiModelService['createAiModel'] = async (params) => {
+    return lambdaClient.aiModel.createAiModel.mutate(params);
+  };
+
+  getAiProviderModelList: IAiModelService['getAiProviderModelList'] = async (id) => {
+    return lambdaClient.aiModel.getAiProviderModelList.query({ id });
+  };
+
+  getAiModelById: IAiModelService['getAiModelById'] = async (id) => {
+    return lambdaClient.aiModel.getAiModelById.query({ id });
+  };
+
+  toggleModelEnabled: IAiModelService['toggleModelEnabled'] = async (params) => {
+    return lambdaClient.aiModel.toggleModelEnabled.mutate(params);
+  };
+
+  updateAiModel: IAiModelService['updateAiModel'] = async (id, providerId, value) => {
+    return lambdaClient.aiModel.updateAiModel.mutate({ id, providerId, value });
+  };
+
+  batchUpdateAiModels: IAiModelService['batchUpdateAiModels'] = async (id, models) => {
+    return lambdaClient.aiModel.batchUpdateAiModels.mutate({ id, models });
+  };
+
+  batchToggleAiModels: IAiModelService['batchToggleAiModels'] = async (id, models, enabled) => {
+    return lambdaClient.aiModel.batchToggleAiModels.mutate({ enabled, id, models });
+  };
+
+  clearRemoteModels: IAiModelService['clearRemoteModels'] = async (providerId) => {
+    return lambdaClient.aiModel.clearRemoteModels.mutate({ providerId });
+  };
+
+  updateAiModelOrder: IAiModelService['updateAiModelOrder'] = async (providerId, items) => {
+    return lambdaClient.aiModel.updateAiModelOrder.mutate({ providerId, sortMap: items });
+  };
+
+  deleteAiModel: IAiModelService['deleteAiModel'] = async (params: {
+    id: string;
+    providerId: string;
+  }) => {
+    return lambdaClient.aiModel.removeAiModel.mutate(params);
+  };
+}

package/src/services/aiModel/type.ts

@@ -0,0 +1,30 @@
+/* eslint-disable typescript-sort-keys/interface */
+import {
+  AiModelSortMap,
+  AiProviderModelListItem,
+  CreateAiModelParams,
+  ToggleAiModelEnableParams,
+  UpdateAiModelParams,
+} from '@/types/aiModel';
+
+export interface IAiModelService {
+  createAiModel: (params: CreateAiModelParams) => Promise<any>;
+
+  getAiProviderModelList: (id: string) => Promise<AiProviderModelListItem[]>;
+
+  getAiModelById: (id: string) => Promise<any>;
+
+  toggleModelEnabled: (params: ToggleAiModelEnableParams) => Promise<any>;
+
+  updateAiModel: (id: string, providerId: string, value: UpdateAiModelParams) => Promise<any>;
+
+  batchUpdateAiModels: (id: string, models: AiProviderModelListItem[]) => Promise<any>;
+
+  batchToggleAiModels: (id: string, models: string[], enabled: boolean) => Promise<any>;
+
+  clearRemoteModels: (providerId: string) => Promise<any>;
+
+  updateAiModelOrder: (providerId: string, items: AiModelSortMap[]) => Promise<any>;
+
+  deleteAiModel: (params: { id: string; providerId: string }) => Promise<any>;
+}

package/src/services/aiProvider/client.ts

@@ -0,0 +1,64 @@
+import { clientDB } from '@/database/client/db';
+import { AiInfraRepos } from '@/database/repositories/aiInfra';
+import { AiProviderModel } from '@/database/server/models/aiProvider';
+import { BaseClientService } from '@/services/baseClientService';
+
+import { IAiProviderService } from './type';
+
+export class ClientService extends BaseClientService implements IAiProviderService {
+  private get aiProviderModel(): AiProviderModel {
+    return new AiProviderModel(clientDB as any, this.userId);
+  }
+  private get aiInfraRepos(): AiInfraRepos {
+    let config = {};
+    if (typeof window !== 'undefined') {
+      config = window.global_serverConfigStore.getState().serverConfig.aiProvider || {};
+    }
+
+    return new AiInfraRepos(clientDB as any, this.userId, config);
+  }
+
+  createAiProvider: IAiProviderService['createAiProvider'] = async (params) => {
+    const data = await this.aiProviderModel.create(params);
+
+    return data?.id;
+  };
+
+  getAiProviderById: IAiProviderService['getAiProviderById'] = async (id) => {
+    return this.aiProviderModel.getAiProviderById(id);
+  };
+
+  getAiProviderList: IAiProviderService['getAiProviderList'] = async () => {
+    return await this.aiInfraRepos.getAiProviderList();
+  };
+
+  getAiProviderRuntimeState: IAiProviderService['getAiProviderRuntimeState'] = async () => {
+    const runtimeConfig = await this.aiProviderModel.getAiProviderRuntimeConfig();
+
+    const enabledAiProviders = await this.aiInfraRepos.getUserEnabledProviderList();
+
+    const enabledAiModels = await this.aiInfraRepos.getEnabledModels();
+
+    return { enabledAiModels, enabledAiProviders, runtimeConfig };
+  };
+
+  toggleProviderEnabled: IAiProviderService['toggleProviderEnabled'] = async (id, enabled) => {
+    return this.aiProviderModel.toggleProviderEnabled(id, enabled);
+  };
+
+  updateAiProvider: IAiProviderService['updateAiProvider'] = async (id, value) => {
+    return this.aiProviderModel.update(id, value);
+  };
+
+  updateAiProviderConfig: IAiProviderService['updateAiProviderConfig'] = async (id, value) => {
+    return this.aiProviderModel.updateConfig(id, value);
+  };
+
+  updateAiProviderOrder: IAiProviderService['updateAiProviderOrder'] = async (items) => {
+    return this.aiProviderModel.updateOrder(items);
+  };
+
+  deleteAiProvider: IAiProviderService['deleteAiProvider'] = async (id) => {
+    return this.aiProviderModel.delete(id);
+  };
+}

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

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

package/src/services/aiProvider/index.ts

@@ -0,0 +1,5 @@
+import { ClientService } from './client';
+import { ServerService } from './server';
+
+export const aiProviderService =
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : new ClientService();

package/src/services/aiProvider/server.ts

@@ -0,0 +1,43 @@
+import { lambdaClient } from '@/libs/trpc/client';
+
+import { IAiProviderService } from './type';
+
+export class ServerService implements IAiProviderService {
+  createAiProvider: IAiProviderService['createAiProvider'] = async (params) => {
+    return lambdaClient.aiProvider.createAiProvider.mutate(params);
+  };
+
+  getAiProviderList: IAiProviderService['getAiProviderList'] = async () => {
+    return lambdaClient.aiProvider.getAiProviderList.query();
+  };
+
+  getAiProviderById: IAiProviderService['getAiProviderById'] = async (id) => {
+    return lambdaClient.aiProvider.getAiProviderById.query({ id });
+  };
+
+  toggleProviderEnabled: IAiProviderService['toggleProviderEnabled'] = async (id, enabled) => {
+    return lambdaClient.aiProvider.toggleProviderEnabled.mutate({ enabled, id });
+  };
+
+  updateAiProvider: IAiProviderService['updateAiProvider'] = async (id, value) => {
+    return lambdaClient.aiProvider.updateAiProvider.mutate({ id, value });
+  };
+
+  updateAiProviderConfig: IAiProviderService['updateAiProviderConfig'] = async (id, value) => {
+    return lambdaClient.aiProvider.updateAiProviderConfig.mutate({ id, value });
+  };
+
+  updateAiProviderOrder: IAiProviderService['updateAiProviderOrder'] = async (items) => {
+    return lambdaClient.aiProvider.updateAiProviderOrder.mutate({ sortMap: items });
+  };
+
+  deleteAiProvider: IAiProviderService['deleteAiProvider'] = async (id) => {
+    return lambdaClient.aiProvider.removeAiProvider.mutate({ id });
+  };
+
+  getAiProviderRuntimeState: IAiProviderService['getAiProviderRuntimeState'] = async (
+    isLogin?: boolean,
+  ) => {
+    return lambdaClient.aiProvider.getAiProviderRuntimeState.query({ isLogin });
+  };
+}

package/src/services/aiProvider/type.ts

@@ -0,0 +1,26 @@
+import {
+  AiProviderRuntimeState,
+  AiProviderSortMap,
+  CreateAiProviderParams,
+  UpdateAiProviderConfigParams,
+} from '@/types/aiProvider';
+
+export interface IAiProviderService {
+  createAiProvider: (params: CreateAiProviderParams) => Promise<any>;
+
+  deleteAiProvider: (id: string) => Promise<any>;
+
+  getAiProviderById: (id: string) => Promise<any>;
+
+  getAiProviderList: () => Promise<any>;
+
+  getAiProviderRuntimeState: (isLogin?: boolean) => Promise<AiProviderRuntimeState>;
+
+  toggleProviderEnabled: (id: string, enabled: boolean) => Promise<any>;
+
+  updateAiProvider: (id: string, value: any) => Promise<any>;
+
+  updateAiProviderConfig: (id: string, value: UpdateAiProviderConfigParams) => Promise<any>;
+
+  updateAiProviderOrder: (items: AiProviderSortMap[]) => Promise<any>;
+}

package/src/services/chat.ts

@@ -7,7 +7,7 @@ import { INBOX_GUIDE_SYSTEMROLE } from '@/const/guide';
 import { INBOX_SESSION_ID } from '@/const/session';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { TracePayload, TraceTagMap } from '@/const/trace';
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition, isServerMode } from '@/const/version';
 import {
   AgentRuntime,
   AgentRuntimeError,
@@ -42,7 +42,7 @@ import { API_ENDPOINTS } from './_url';
 
 const isCanUseFC = (model: string, provider: string) => {
   // TODO: remove isDeprecatedEdition condition in V2.0
-  if (!isServerMode) {
+  if (isDeprecatedEdition) {
     return modelProviderSelectors.isModelEnabledFunctionCall(model)(useUserStore.getState());
   }
 
@@ -53,7 +53,7 @@ const findAzureDeploymentName = (model: string) => {
   let deploymentId = model;
 
   // TODO: remove isDeprecatedEdition condition in V2.0
-  if (!isServerMode) {
+  if (isDeprecatedEdition) {
     const chatModelCards = modelProviderSelectors.getModelCardsById(ModelProvider.Azure)(
       useUserStore.getState(),
     );
@@ -74,7 +74,7 @@ const findAzureDeploymentName = (model: string) => {
 
 const isEnableFetchOnClient = (provider: string) => {
   // TODO: remove this condition in V2.0
-  if (!isServerMode) {
+  if (isDeprecatedEdition) {
     return modelConfigSelectors.isProviderFetchOnClient(provider)(useUserStore.getState());
   } else {
     return aiProviderSelectors.isProviderFetchOnClient(provider)(useAiInfraStore.getState());
@@ -341,7 +341,7 @@ class ChatService {
     const isBuiltin = Object.values(ModelProvider).includes(provider as any);
 
     // TODO: remove `!isDeprecatedEdition` condition in V2.0
-    if (isServerMode && !isBuiltin) {
+    if (!isDeprecatedEdition && !isBuiltin) {
       const providerConfig = aiProviderSelectors.providerConfigById(provider)(
         useAiInfraStore.getState(),
       );

package/src/services/tableViewer/client.ts

@@ -0,0 +1,16 @@
+import { clientDB } from '@/database/client/db';
+import { TableViewerRepo } from '@/database/repositories/tableViewer';
+import { BaseClientService } from '@/services/baseClientService';
+
+export class ClientService extends BaseClientService {
+  private get tableViewerRepo(): TableViewerRepo {
+    return new TableViewerRepo(clientDB as any, this.userId);
+  }
+
+  getAllTables = async () => this.tableViewerRepo.getAllTables();
+
+  getTableDetails = async (tableName: string) => this.tableViewerRepo.getTableDetails(tableName);
+
+  getTableData = async (tableName: string) =>
+    this.tableViewerRepo.getTableData(tableName, { page: 1, pageSize: 300 });
+}

package/src/services/tableViewer/index.ts

@@ -0,0 +1,3 @@
+import { ClientService } from './client';
+
+export const tableViewerService = new ClientService();

package/src/store/aiInfra/slices/aiProvider/action.ts

@@ -3,7 +3,7 @@ import { SWRResponse, mutate } from 'swr';
 import { StateCreator } from 'zustand/vanilla';
 
 import { DEFAULT_MODEL_PROVIDER_LIST } from '@/config/modelProviders';
-import { isServerMode } from '@/const/version';
+import { isDeprecatedEdition } from '@/const/version';
 import { useClientDataSWR } from '@/libs/swr';
 import { aiProviderService } from '@/services/aiProvider';
 import { AiInfraStore } from '@/store/aiInfra/store';
@@ -170,7 +170,7 @@ export const createAiProviderSlice: StateCreator<
 
   useFetchAiProviderRuntimeState: (isLogin) =>
     useClientDataSWR<AiProviderRuntimeState | undefined>(
-      isServerMode ? [AiProviderSwrKey.fetchAiProviderRuntimeState, isLogin] : null,
+      !isDeprecatedEdition ? [AiProviderSwrKey.fetchAiProviderRuntimeState, isLogin] : null,
       async ([, isLogin]) => {
         if (isLogin) return aiProviderService.getAiProviderRuntimeState();
 

package/src/types/knowledgeBase/index.ts

@@ -48,6 +48,6 @@ export interface KnowledgeItem {
 
 export interface SystemEmbeddingConfig {
   embeddingModel: FilesConfigItem;
-  queryModel: string;
+  queryMode: string;
   rerankerModel: FilesConfigItem;
 }

package/src/types/serverConfig.ts

@@ -24,7 +24,13 @@ export interface GlobalServerConfig {
   defaultAgent?: DeepPartial<UserDefaultAgent>;
   enableUploadFileToServer?: boolean;
   enabledAccessCode?: boolean;
+  /**
+   * @deprecated
+   */
   enabledOAuthSSO?: boolean;
+  /**
+   * @deprecated
+   */
   languageModel?: ServerLanguageModel;
   oAuthSSOProviders?: string[];
   systemAgent?: DeepPartial<UserSystemAgentConfig>;

package/src/types/tableViewer.ts

@@ -0,0 +1,30 @@
+export interface TableBasicInfo {
+  count: number;
+  name: string;
+  type: 'BASE TABLE' | 'VIEW';
+}
+
+export interface TableColumnInfo {
+  defaultValue?: string;
+  foreignKey?: {
+    column: string;
+    table: string;
+  };
+  isPrimaryKey: boolean;
+  name: string;
+  nullable: boolean;
+  type: string;
+}
+
+export interface PaginationParams {
+  page: number;
+  pageSize: number;
+  sortBy?: string;
+  sortOrder?: 'asc' | 'desc';
+}
+
+export interface FilterCondition {
+  column: string;
+  operator: 'equals' | 'contains' | 'startsWith' | 'endsWith';
+  value: any;
+}

package/src/types/user/settings/filesConfig.ts

@@ -4,6 +4,6 @@ export interface FilesConfigItem {
 }
 export interface FilesConfig {
   embeddingModel: FilesConfigItem;
-  queryModel: string;
+  queryMode: string;
   rerankerModel: FilesConfigItem;
 }

package/tests/utils.tsx

@@ -9,3 +9,49 @@ const swrConfig = {
 export const withSWR = ({ children }: PropsWithChildren) => (
   <SWRConfig value={swrConfig}>{children}</SWRConfig>
 );
+
+interface TestServiceOptions {
+  /** 是否检查 async */
+  checkAsync?: boolean;
+  /** 自定义的额外检查 */
+  extraChecks?: (method: string, func: () => any) => void;
+  /** 是否跳过某些方法 */
+  skipMethods?: string[];
+}
+
+const builtinSkipProps = new Set(['userId']);
+
+export const testService = (ServiceClass: new () => any, options: TestServiceOptions = {}) => {
+  const { checkAsync = true, skipMethods = ['userId'], extraChecks } = options;
+
+  describe(ServiceClass.name, () => {
+    it('should implement all methods as arrow functions', () => {
+      const service = new ServiceClass();
+
+      const methods = Object.getOwnPropertyNames(service).filter(
+        (method) => !builtinSkipProps.has(method) || !skipMethods.includes(method),
+      );
+
+      methods.forEach((method) => {
+        const func = service[method];
+        // 检查是否为函数
+        expect(typeof func).toBe('function');
+
+        const funcString = func.toString();
+
+        // 验证是否是箭头函数
+        expect(funcString).toContain('=>');
+
+        // 可选的 async 检查
+        if (checkAsync) {
+          expect(funcString).toMatch(/^async.*=>/);
+        }
+
+        // 运行额外的自定义检查
+        if (extraChecks) {
+          extraChecks(method, func);
+        }
+      });
+    });
+  });
+};

package/src/features/DebugUI/Content.tsx

@@ -1,34 +0,0 @@
-import { Icon } from '@lobehub/ui';
-import { App, FloatButton, Spin } from 'antd';
-import { DatabaseIcon, Loader2 } from 'lucide-react';
-import { memo, useState } from 'react';
-
-import { debugService } from '@/services/debug';
-
-const DebugUI = memo(() => {
-  const [loading, setLoading] = useState(false);
-  const { message } = App.useApp();
-  return (
-    <>
-      {loading && <Spin fullscreen />}
-      <FloatButton
-        icon={<Icon icon={loading ? Loader2 : DatabaseIcon} spin={loading} />}
-        onClick={async () => {
-          setLoading(true);
-
-          const startTime = Date.now();
-
-          await debugService.insertLargeDataToDB();
-
-          const duration = Date.now() - startTime;
-
-          setLoading(false);
-          message.success(`插入成功，耗时：${(duration / 1000).toFixed(1)} s`);
-        }}
-        tooltip={'性能压测，插入100w数据'}
-      />
-    </>
-  );
-});
-
-export default DebugUI;

package/src/features/DebugUI/index.tsx

@@ -1,20 +0,0 @@
-'use client';
-
-import dynamic from 'next/dynamic';
-import { FC } from 'react';
-
-import { getDebugConfig } from '@/config/debug';
-
-let DebugUI: FC = () => null;
-
-// we need use Constant Folding to remove code below in production
-// refs: https://webpack.js.org/plugins/internal-plugins/#constplugin
-if (process.env.NODE_ENV === 'development') {
-  // eslint-disable-next-line unicorn/no-lonely-if
-  if (getDebugConfig().DEBUG_MODE) {
-    // @ts-ignore
-    DebugUI = dynamic(() => import('./Content'), { ssr: false });
-  }
-}
-
-export default DebugUI;

package/src/services/aiModel.ts

@@ -1,52 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-import {
-  AiModelSortMap,
-  AiProviderModelListItem,
-  CreateAiModelParams,
-  ToggleAiModelEnableParams,
-  UpdateAiModelParams,
-} from '@/types/aiModel';
-
-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 });
-  };
-
-  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.ts

@@ -1,47 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-import {
-  AiProviderRuntimeState,
-  AiProviderSortMap,
-  CreateAiProviderParams,
-  UpdateAiProviderConfigParams,
-} from '@/types/aiProvider';
-
-class AiProviderService {
-  createAiProvider = async (params: CreateAiProviderParams) => {
-    return lambdaClient.aiProvider.createAiProvider.mutate(params);
-  };
-
-  getAiProviderList = async () => {
-    return lambdaClient.aiProvider.getAiProviderList.query();
-  };
-
-  getAiProviderById = async (id: string) => {
-    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();