@lobehub/chat 1.43.6 → 1.44.1

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

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+
+import { AiInfraRepos } from '@/database/repositories/aiInfra';
+import { serverDB } from '@/database/server';
+import { AiModelModel } from '@/database/server/models/aiModel';
+import { UserModel } from '@/database/server/models/user';
+import { authedProcedure, router } from '@/libs/trpc';
+import { getServerGlobalConfig } from '@/server/globalConfig';
+import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
+import {
+  AiProviderModelListItem,
+  CreateAiModelSchema,
+  ToggleAiModelEnableSchema,
+  UpdateAiModelSchema,
+} from '@/types/aiModel';
+import { ProviderConfig } from '@/types/user/settings';
+
+const aiModelProcedure = authedProcedure.use(async (opts) => {
+  const { ctx } = opts;
+
+  const gateKeeper = await KeyVaultsGateKeeper.initWithEnvKey();
+  const { languageModel } = getServerGlobalConfig();
+
+  return opts.next({
+    ctx: {
+      aiInfraRepos: new AiInfraRepos(
+        serverDB,
+        ctx.userId,
+        languageModel as Record<string, ProviderConfig>,
+      ),
+      aiModelModel: new AiModelModel(serverDB, ctx.userId),
+      gateKeeper,
+      userModel: new UserModel(serverDB, ctx.userId),
+    },
+  });
+});
+
+export const aiModelRouter = router({
+  batchToggleAiModels: aiModelProcedure
+    .input(
+      z.object({
+        enabled: z.boolean(),
+        id: z.string(),
+        models: z.array(z.string()),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiModelModel.batchToggleAiModels(input.id, input.models, input.enabled);
+    }),
+  batchUpdateAiModels: aiModelProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        // TODO: 补齐校验 Schema
+        models: z.array(z.any()),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiModelModel.batchUpdateAiModels(input.id, input.models);
+    }),
+
+  clearRemoteModels: aiModelProcedure
+    .input(z.object({ providerId: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiModelModel.clearRemoteModels(input.providerId);
+    }),
+
+  createAiModel: aiModelProcedure.input(CreateAiModelSchema).mutation(async ({ input, ctx }) => {
+    const data = await ctx.aiModelModel.create(input);
+
+    return data?.id;
+  }),
+
+  getAiModelById: aiModelProcedure
+    .input(z.object({ id: z.string() }))
+
+    .query(async ({ input, ctx }) => {
+      return ctx.aiModelModel.findById(input.id);
+    }),
+
+  getAiProviderModelList: aiModelProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ ctx, input }): Promise<AiProviderModelListItem[]> => {
+      return ctx.aiInfraRepos.getAiProviderModelList(input.id);
+    }),
+
+  removeAiModel: aiModelProcedure
+    .input(z.object({ id: z.string(), providerId: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiModelModel.delete(input.id, input.providerId);
+    }),
+
+  toggleModelEnabled: aiModelProcedure
+    .input(ToggleAiModelEnableSchema)
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiModelModel.toggleModelEnabled(input);
+    }),
+
+  updateAiModel: aiModelProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        providerId: z.string(),
+        value: UpdateAiModelSchema,
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiModelModel.update(input.id, input.providerId, input.value);
+    }),
+
+  updateAiModelOrder: aiModelProcedure
+    .input(
+      z.object({
+        providerId: z.string(),
+        sortMap: z.array(
+          z.object({
+            id: z.string(),
+            sort: z.number(),
+          }),
+        ),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiModelModel.updateModelsOrder(input.providerId, input.sortMap);
+    }),
+});
+
+export type AiModelRouter = typeof aiModelRouter;

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

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+
+import { AiInfraRepos } from '@/database/repositories/aiInfra';
+import { serverDB } from '@/database/server';
+import { AiProviderModel } from '@/database/server/models/aiProvider';
+import { UserModel } from '@/database/server/models/user';
+import { authedProcedure, router } from '@/libs/trpc';
+import { getServerGlobalConfig } from '@/server/globalConfig';
+import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
+import {
+  AiProviderDetailItem,
+  AiProviderRuntimeState,
+  CreateAiProviderSchema,
+  UpdateAiProviderConfigSchema,
+} from '@/types/aiProvider';
+import { ProviderConfig } from '@/types/user/settings';
+
+const aiProviderProcedure = authedProcedure.use(async (opts) => {
+  const { ctx } = opts;
+
+  const { languageModel } = getServerGlobalConfig();
+
+  const gateKeeper = await KeyVaultsGateKeeper.initWithEnvKey();
+  return opts.next({
+    ctx: {
+      aiInfraRepos: new AiInfraRepos(
+        serverDB,
+        ctx.userId,
+        languageModel as Record<string, ProviderConfig>,
+      ),
+      aiProviderModel: new AiProviderModel(serverDB, ctx.userId),
+      gateKeeper,
+      userModel: new UserModel(serverDB, ctx.userId),
+    },
+  });
+});
+
+export const aiProviderRouter = router({
+  createAiProvider: aiProviderProcedure
+    .input(CreateAiProviderSchema)
+    .mutation(async ({ input, ctx }) => {
+      const data = await ctx.aiProviderModel.create(input, ctx.gateKeeper.encrypt);
+
+      return data?.id;
+    }),
+
+  getAiProviderById: aiProviderProcedure
+    .input(z.object({ id: z.string() }))
+
+    .query(async ({ input, ctx }): Promise<AiProviderDetailItem | undefined> => {
+      return ctx.aiProviderModel.getAiProviderById(input.id, KeyVaultsGateKeeper.getUserKeyVaults);
+    }),
+
+  getAiProviderList: aiProviderProcedure.query(async ({ ctx }) => {
+    return await ctx.aiInfraRepos.getAiProviderList();
+  }),
+
+  getAiProviderRuntimeState: aiProviderProcedure
+    .input(z.object({ isLogin: z.boolean().optional() }))
+    .query(async ({ ctx }): Promise<AiProviderRuntimeState> => {
+      const runtimeConfig = await ctx.aiProviderModel.getAiProviderRuntimeConfig(
+        KeyVaultsGateKeeper.getUserKeyVaults,
+      );
+
+      const enabledAiProviders = await ctx.aiInfraRepos.getUserEnabledProviderList();
+
+      const enabledAiModels = await ctx.aiInfraRepos.getEnabledModels();
+
+      return { enabledAiModels, enabledAiProviders, runtimeConfig };
+    }),
+
+  removeAiProvider: aiProviderProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiProviderModel.delete(input.id);
+    }),
+
+  toggleProviderEnabled: aiProviderProcedure
+    .input(
+      z.object({
+        enabled: z.boolean(),
+        id: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiProviderModel.toggleProviderEnabled(input.id, input.enabled);
+    }),
+
+  updateAiProvider: aiProviderProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: CreateAiProviderSchema.partial(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiProviderModel.update(input.id, input.value);
+    }),
+
+  updateAiProviderConfig: aiProviderProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: UpdateAiProviderConfigSchema,
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiProviderModel.updateConfig(input.id, input.value, ctx.gateKeeper.encrypt);
+    }),
+
+  updateAiProviderOrder: aiProviderProcedure
+    .input(
+      z.object({
+        sortMap: z.array(
+          z.object({
+            id: z.string(),
+            sort: z.number(),
+          }),
+        ),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiProviderModel.updateOrder(input.sortMap);
+    }),
+});
+
+export type AiProviderRouter = typeof aiProviderRouter;

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

@@ -4,6 +4,8 @@
 import { publicProcedure, router } from '@/libs/trpc';
 
 import { agentRouter } from './agent';
+import { aiModelRouter } from './aiModel';
+import { aiProviderRouter } from './aiProvider';
 import { chunkRouter } from './chunk';
 import { fileRouter } from './file';
 import { importerRouter } from './importer';
@@ -19,6 +21,8 @@ import { userRouter } from './user';
 
 export const lambdaRouter = router({
   agent: agentRouter,
+  aiModel: aiModelRouter,
+  aiProvider: aiProviderRouter,
   chunk: chunkRouter,
   file: fileRouter,
   healthcheck: publicProcedure.query(() => "i'm live!"),

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

@@ -34,29 +34,19 @@ const setModelProviderConfig = <T extends GlobalLLMProviderKey>(
 
 describe('getProviderAuthPayload', () => {
   it('should return correct payload for ZhiPu provider', () => {
-    act(() => {
-      setModelProviderConfig('zhipu', { apiKey: mockZhiPuAPIKey });
-    });
-
-    const payload = getProviderAuthPayload(ModelProvider.ZhiPu);
+    const payload = getProviderAuthPayload(ModelProvider.ZhiPu, { apiKey: mockZhiPuAPIKey });
     expect(payload).toEqual({ apiKey: mockZhiPuAPIKey });
   });
 
   it('should return correct payload for Moonshot provider', () => {
-    act(() => {
-      setModelProviderConfig('moonshot', { apiKey: mockMoonshotAPIKey });
-    });
-
-    const payload = getProviderAuthPayload(ModelProvider.Moonshot);
+    const payload = getProviderAuthPayload(ModelProvider.Moonshot, { apiKey: mockMoonshotAPIKey });
     expect(payload).toEqual({ apiKey: mockMoonshotAPIKey });
   });
 
   it('should return correct payload for Anthropic provider', () => {
-    act(() => {
-      setModelProviderConfig('anthropic', { apiKey: mockAnthropicAPIKey });
+    const payload = getProviderAuthPayload(ModelProvider.Anthropic, {
+      apiKey: mockAnthropicAPIKey,
     });
-
-    const payload = getProviderAuthPayload(ModelProvider.Anthropic);
     expect(payload).toEqual({ apiKey: mockAnthropicAPIKey });
   });
 
@@ -65,34 +55,26 @@ describe('getProviderAuthPayload', () => {
       setModelProviderConfig('mistral', { apiKey: mockMistralAPIKey });
     });
 
-    const payload = getProviderAuthPayload(ModelProvider.Mistral);
+    const payload = getProviderAuthPayload(ModelProvider.Mistral, { apiKey: mockMistralAPIKey });
     expect(payload).toEqual({ apiKey: mockMistralAPIKey });
   });
 
   it('should return correct payload for OpenRouter provider', () => {
-    act(() => {
-      setModelProviderConfig('openrouter', { apiKey: mockOpenRouterAPIKey });
+    const payload = getProviderAuthPayload(ModelProvider.OpenRouter, {
+      apiKey: mockOpenRouterAPIKey,
     });
-
-    const payload = getProviderAuthPayload(ModelProvider.OpenRouter);
     expect(payload).toEqual({ apiKey: mockOpenRouterAPIKey });
   });
 
   it('should return correct payload for TogetherAI provider', () => {
-    act(() => {
-      setModelProviderConfig('togetherai', { apiKey: mockTogetherAIAPIKey });
+    const payload = getProviderAuthPayload(ModelProvider.TogetherAI, {
+      apiKey: mockTogetherAIAPIKey,
     });
-
-    const payload = getProviderAuthPayload(ModelProvider.TogetherAI);
     expect(payload).toEqual({ apiKey: mockTogetherAIAPIKey });
   });
 
   it('should return correct payload for Google provider', () => {
-    act(() => {
-      setModelProviderConfig('google', { apiKey: mockGoogleAPIKey });
-    });
-
-    const payload = getProviderAuthPayload(ModelProvider.Google);
+    const payload = getProviderAuthPayload(ModelProvider.Google, { apiKey: mockGoogleAPIKey });
     expect(payload).toEqual({ apiKey: mockGoogleAPIKey });
   });
 
@@ -103,11 +85,8 @@ describe('getProviderAuthPayload', () => {
       region: 'bedrock-region',
       secretAccessKey: 'bedrock-secret-access-key',
     };
-    act(() => {
-      setModelProviderConfig('bedrock', mockBedrockConfig);
-    });
 
-    const payload = getProviderAuthPayload(ModelProvider.Bedrock);
+    const payload = getProviderAuthPayload(ModelProvider.Bedrock, mockBedrockConfig);
     expect(payload).toEqual({
       apiKey: mockBedrockConfig.secretAccessKey + mockBedrockConfig.accessKeyId,
       awsAccessKeyId: mockBedrockConfig.accessKeyId,
@@ -123,11 +102,8 @@ describe('getProviderAuthPayload', () => {
       apiVersion: 'azure-api-version',
       endpoint: 'azure-endpoint',
     };
-    act(() => {
-      setModelProviderConfig('azure', mockAzureConfig);
-    });
 
-    const payload = getProviderAuthPayload(ModelProvider.Azure);
+    const payload = getProviderAuthPayload(ModelProvider.Azure, mockAzureConfig);
     expect(payload).toEqual({
       apiKey: mockAzureConfig.apiKey,
       azureApiVersion: mockAzureConfig.apiVersion,
@@ -138,11 +114,8 @@ describe('getProviderAuthPayload', () => {
   it('should return correct payload for Ollama provider', () => {
     // 假设的 Ollama 配置
     const mockOllamaProxyUrl = 'ollama-proxy-url';
-    act(() => {
-      setModelProviderConfig('ollama', { baseURL: mockOllamaProxyUrl });
-    });
 
-    const payload = getProviderAuthPayload(ModelProvider.Ollama);
+    const payload = getProviderAuthPayload(ModelProvider.Ollama, { baseURL: mockOllamaProxyUrl });
     expect(payload).toEqual({
       baseURL: mockOllamaProxyUrl,
     });
@@ -156,11 +129,8 @@ describe('getProviderAuthPayload', () => {
       useAzure: true,
       azureApiVersion: 'openai-azure-api-version',
     };
-    act(() => {
-      setModelProviderConfig('openai', mockOpenAIConfig);
-    });
 
-    const payload = getProviderAuthPayload(ModelProvider.OpenAI);
+    const payload = getProviderAuthPayload(ModelProvider.OpenAI, mockOpenAIConfig);
     expect(payload).toEqual({
       apiKey: mockOpenAIConfig.apiKey,
       baseURL: mockOpenAIConfig.baseURL,
@@ -173,11 +143,8 @@ describe('getProviderAuthPayload', () => {
       apiKey: 'stepfun-api-key',
       baseURL: 'stepfun-baseURL',
     };
-    act(() => {
-      setModelProviderConfig('stepfun', mockOpenAIConfig);
-    });
 
-    const payload = getProviderAuthPayload(ModelProvider.Stepfun);
+    const payload = getProviderAuthPayload(ModelProvider.Stepfun, mockOpenAIConfig);
     expect(payload).toEqual({
       apiKey: mockOpenAIConfig.apiKey,
       baseURL: mockOpenAIConfig.baseURL,
@@ -185,7 +152,7 @@ describe('getProviderAuthPayload', () => {
   });
 
   it('should return an empty object or throw an error for an unknown provider', () => {
-    const payload = getProviderAuthPayload('UnknownProvider');
+    const payload = getProviderAuthPayload('UnknownProvider', {});
     expect(payload).toEqual({});
   });
 });

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

@@ -60,6 +60,7 @@ beforeEach(() => {
   // 默认设置 isServerMode 为 false
   vi.mock('@/const/version', () => ({
     isServerMode: false,
+    isDeprecatedEdition: true,
   }));
 });
 
@@ -836,6 +837,7 @@ describe('ChatService', () => {
       // 重新模拟模块，设置 isServerMode 为 true
       vi.doMock('@/const/version', () => ({
         isServerMode: true,
+        isDeprecatedEdition: true,
       }));
 
       // 需要在修改模拟后重新导入相关模块

package/src/services/_auth.ts

@@ -1,15 +1,29 @@
 import { JWTPayload, LOBE_CHAT_AUTH_HEADER } from '@/const/auth';
+import { isServerMode } from '@/const/version';
 import { ModelProvider } from '@/libs/agent-runtime';
+import { aiProviderSelectors, useAiInfraStore } from '@/store/aiInfra';
 import { useUserStore } from '@/store/user';
 import { keyVaultsConfigSelectors, userProfileSelectors } from '@/store/user/selectors';
-import { GlobalLLMProviderKey } from '@/types/user/settings';
+import {
+  AWSBedrockKeyVault,
+  AzureOpenAIKeyVault,
+  CloudflareKeyVault,
+  OpenAICompatibleKeyVault,
+  WenxinKeyVault,
+} from '@/types/user/settings';
 import { createJWT } from '@/utils/jwt';
 
-export const getProviderAuthPayload = (provider: string) => {
+export const getProviderAuthPayload = (
+  provider: string,
+  keyVaults: OpenAICompatibleKeyVault &
+    AzureOpenAIKeyVault &
+    AWSBedrockKeyVault &
+    WenxinKeyVault &
+    CloudflareKeyVault,
+) => {
   switch (provider) {
     case ModelProvider.Bedrock: {
-      const { accessKeyId, region, secretAccessKey, sessionToken } =
-        keyVaultsConfigSelectors.bedrockConfig(useUserStore.getState());
+      const { accessKeyId, region, secretAccessKey, sessionToken } = keyVaults;
 
       const awsSecretAccessKey = secretAccessKey;
       const awsAccessKeyId = accessKeyId;
@@ -26,9 +40,7 @@ export const getProviderAuthPayload = (provider: string) => {
     }
 
     case ModelProvider.Wenxin: {
-      const { secretKey, accessKey } = keyVaultsConfigSelectors.wenxinConfig(
-        useUserStore.getState(),
-      );
+      const { secretKey, accessKey } = keyVaults;
 
       const apiKey = (accessKey || '') + (secretKey || '');
 
@@ -40,36 +52,26 @@ export const getProviderAuthPayload = (provider: string) => {
     }
 
     case ModelProvider.Azure: {
-      const azure = keyVaultsConfigSelectors.azureConfig(useUserStore.getState());
-
       return {
-        apiKey: azure.apiKey,
-        azureApiVersion: azure.apiVersion,
-        baseURL: azure.endpoint,
+        apiKey: keyVaults.apiKey,
+        azureApiVersion: keyVaults.apiVersion,
+        baseURL: keyVaults.endpoint,
       };
     }
 
     case ModelProvider.Ollama: {
-      const config = keyVaultsConfigSelectors.ollamaConfig(useUserStore.getState());
-
-      return { baseURL: config?.baseURL };
+      return { baseURL: keyVaults?.baseURL };
     }
 
     case ModelProvider.Cloudflare: {
-      const config = keyVaultsConfigSelectors.cloudflareConfig(useUserStore.getState());
-
       return {
-        apiKey: config?.apiKey,
-        cloudflareBaseURLOrAccountID: config?.baseURLOrAccountID,
+        apiKey: keyVaults?.apiKey,
+        cloudflareBaseURLOrAccountID: keyVaults?.baseURLOrAccountID,
       };
     }
 
     default: {
-      const config = keyVaultsConfigSelectors.getVaultByProvider(provider as GlobalLLMProviderKey)(
-        useUserStore.getState(),
-      );
-
-      return { apiKey: config?.apiKey, baseURL: config?.baseURL };
+      return { apiKey: keyVaults?.apiKey, baseURL: keyVaults?.baseURL };
     }
   }
 };
@@ -88,12 +90,27 @@ interface AuthParams {
   provider?: string;
 }
 
+export const createPayloadWithKeyVaults = (provider: string) => {
+  let keyVaults = {};
+
+  // TODO: remove this condition in V2.0
+  if (!isServerMode) {
+    keyVaults = keyVaultsConfigSelectors.getVaultByProvider(provider as any)(
+      useUserStore.getState(),
+    );
+  } else {
+    keyVaults = aiProviderSelectors.providerKeyVaults(provider)(useAiInfraStore.getState()) || {};
+  }
+
+  return getProviderAuthPayload(provider, keyVaults);
+};
+
 // eslint-disable-next-line no-undef
 export const createHeaderWithAuth = async (params?: AuthParams): Promise<HeadersInit> => {
   let payload = params?.payload || {};
 
   if (params?.provider) {
-    payload = { ...payload, ...getProviderAuthPayload(params?.provider) };
+    payload = { ...payload, ...createPayloadWithKeyVaults(params?.provider) };
   }
 
   const token = await createAuthTokenWithPayload(payload);

package/src/services/aiModel.ts

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,47 @@
+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();