@lobehub/chat 1.43.6 → 1.44.0

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();

package/src/services/chat.ts

@@ -16,6 +16,7 @@ import {
 } from '@/libs/agent-runtime';
 import { filesPrompts } from '@/prompts/files';
 import { BuiltinSystemRolePrompts } from '@/prompts/systemRole';
+import { aiModelSelectors, aiProviderSelectors, useAiInfraStore } from '@/store/aiInfra';
 import { useSessionStore } from '@/store/session';
 import { sessionMetaSelectors } from '@/store/session/selectors';
 import { useToolStore } from '@/store/tool';
@@ -36,9 +37,50 @@ import { FetchSSEOptions, fetchSSE, getMessageError } from '@/utils/fetch';
 import { genToolCallingName } from '@/utils/toolCall';
 import { createTraceHeader, getTraceId } from '@/utils/trace';
 
-import { createHeaderWithAuth, getProviderAuthPayload } from './_auth';
+import { createHeaderWithAuth, createPayloadWithKeyVaults } from './_auth';
 import { API_ENDPOINTS } from './_url';
 
+const isCanUseFC = (model: string) => {
+  // TODO: remove isDeprecatedEdition condition in V2.0
+  if (!isServerMode) {
+    return modelProviderSelectors.isModelEnabledFunctionCall(model)(useUserStore.getState());
+  }
+
+  return aiModelSelectors.isModelSupportToolUse(model)(useAiInfraStore.getState());
+};
+
+const findAzureDeploymentName = (model: string) => {
+  let deploymentId = model;
+
+  // TODO: remove isDeprecatedEdition condition in V2.0
+  if (!isServerMode) {
+    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 = useAiInfraStore.getState().enabledAiModels?.find((i) => i.id === model);
+
+    if (modelItem && modelItem.config?.deploymentName) {
+      deploymentId = modelItem.config?.deploymentName;
+    }
+  }
+
+  return deploymentId;
+};
+
+const isEnableFetchOnClient = (provider: string) => {
+  // TODO: remove this condition in V2.0
+  if (!isServerMode) {
+    return modelConfigSelectors.isProviderFetchOnClient(provider)(useUserStore.getState());
+  } else {
+    return aiProviderSelectors.isProviderFetchOnClient(provider)(useAiInfraStore.getState());
+  }
+};
+
 interface FetchOptions extends FetchSSEOptions {
   historySummary?: string;
   isWelcomeQuestion?: boolean;
@@ -83,7 +125,7 @@ interface CreateAssistantMessageStream extends FetchSSEOptions {
  */
 export function initializeWithClientStore(provider: string, payload: any) {
   // add auth payload
-  const providerAuthPayload = getProviderAuthPayload(provider);
+  const providerAuthPayload = { ...payload, ...createPayloadWithKeyVaults(provider) };
   const commonOptions = {
     // Some provider base openai sdk, so enable it run on browser
     dangerouslyAllowBrowser: true,
@@ -200,9 +242,8 @@ class ChatService {
     const filterTools = toolSelectors.enabledSchema(enabledPlugins)(useToolStore.getState());
 
     // check this model can use function call
-    const canUseFC = modelProviderSelectors.isModelEnabledFunctionCall(payload.model)(
-      useUserStore.getState(),
-    );
+    const canUseFC = isCanUseFC(payload.model);
+
     // the rule that model can use tools:
     // 1. tools is not empty
     // 2. model can use function call
@@ -245,12 +286,7 @@ class ChatService {
 
     // if the provider is Azure, get the deployment name as the request model
     if (provider === ModelProvider.Azure) {
-      const chatModelCards = modelProviderSelectors.getModelCardsById(provider)(
-        useUserStore.getState(),
-      );
-
-      const deploymentName = chatModelCards.find((i) => i.id === model)?.deploymentName;
-      if (deploymentName) model = deploymentName;
+      model = findAzureDeploymentName(model);
     }
 
     const payload = merge(
@@ -261,9 +297,7 @@ class ChatService {
     /**
      * Use browser agent runtime
      */
-    const enableFetchOnClient = modelConfigSelectors.isProviderFetchOnClient(provider)(
-      useUserStore.getState(),
-    );
+    let enableFetchOnClient = isEnableFetchOnClient(provider);
 
     let fetcher: typeof fetch | undefined = undefined;
 
@@ -302,7 +336,19 @@ class ChatService {
 
     const providerConfig = DEFAULT_MODEL_PROVIDER_LIST.find((item) => item.id === provider);
 
-    return fetchSSE(API_ENDPOINTS.chat(provider), {
+    let sdkType = provider;
+    const isBuiltin = Object.values(ModelProvider).includes(provider as any);
+
+    // TODO: remove `!isDeprecatedEdition` condition in V2.0
+    if (isServerMode && !isBuiltin) {
+      const providerConfig = aiProviderSelectors.providerConfigById(provider)(
+        useAiInfraStore.getState(),
+      );
+
+      sdkType = providerConfig?.settings.sdkType || 'openai';
+    }
+
+    return fetchSSE(API_ENDPOINTS.chat(sdkType), {
       body: JSON.stringify(payload),
       fetcher: fetcher,
       headers,
@@ -467,9 +513,7 @@ class ChatService {
 
       // Inject Tool SystemRole
       const hasTools = tools && tools?.length > 0;
-      const hasFC =
-        hasTools &&
-        modelProviderSelectors.isModelEnabledFunctionCall(model)(useUserStore.getState());
+      const hasFC = hasTools && isCanUseFC(model);
       const toolsSystemRoles =
         hasFC && toolSelectors.enabledSystemRoles(tools)(useToolStore.getState());
 

package/src/store/aiInfra/index.ts

@@ -0,0 +1,2 @@
+export * from './selectors';
+export { useAiInfraStore } from './store';

package/src/store/aiInfra/initialState.ts

@@ -0,0 +1,11 @@
+import { AIModelsState, initialAIModelState } from './slices/aiModel';
+import { AIProviderState, initialAIProviderState } from './slices/aiProvider';
+
+export interface AIProviderStoreState extends AIProviderState, AIModelsState {
+  /* empty */
+}
+
+export const initialState: AIProviderStoreState = {
+  ...initialAIProviderState,
+  ...initialAIModelState,
+};

package/src/store/aiInfra/selectors.ts

@@ -0,0 +1,2 @@
+export * from './slices/aiModel/selectors';
+export * from './slices/aiProvider/selectors';