@lobehub/chat 1.43.6 → 1.44.1

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';

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

@@ -0,0 +1,146 @@
+import isEqual from 'fast-deep-equal';
+import { SWRResponse, mutate } from 'swr';
+import { StateCreator } from 'zustand/vanilla';
+
+import { useClientDataSWR } from '@/libs/swr';
+import { aiModelService } from '@/services/aiModel';
+import { AiInfraStore } from '@/store/aiInfra/store';
+import {
+  AiModelSortMap,
+  AiProviderModelListItem,
+  CreateAiModelParams,
+  ToggleAiModelEnableParams,
+} from '@/types/aiModel';
+
+const FETCH_AI_PROVIDER_MODEL_LIST_KEY = 'FETCH_AI_PROVIDER_MODELS';
+
+export interface AiModelAction {
+  batchToggleAiModels: (ids: string[], enabled: boolean) => Promise<void>;
+  batchUpdateAiModels: (models: AiProviderModelListItem[]) => Promise<void>;
+  clearRemoteModels: (provider: string) => Promise<void>;
+  createNewAiModel: (params: CreateAiModelParams) => Promise<void>;
+  fetchRemoteModelList: (providerId: string) => Promise<void>;
+  internal_toggleAiModelLoading: (id: string, loading: boolean) => void;
+
+  refreshAiModelList: () => Promise<void>;
+  removeAiModel: (id: string, providerId: string) => Promise<void>;
+  toggleModelEnabled: (params: Omit<ToggleAiModelEnableParams, 'providerId'>) => Promise<void>;
+  updateAiModelsConfig: (
+    id: string,
+    providerId: string,
+    data: Partial<AiProviderModelListItem>,
+  ) => Promise<void>;
+  updateAiModelsSort: (providerId: string, items: AiModelSortMap[]) => Promise<void>;
+
+  useFetchAiProviderModels: (id: string) => SWRResponse<AiProviderModelListItem[]>;
+}
+
+export const createAiModelSlice: StateCreator<
+  AiInfraStore,
+  [['zustand/devtools', never]],
+  [],
+  AiModelAction
+> = (set, get) => ({
+  batchToggleAiModels: async (ids, enabled) => {
+    const { activeAiProvider } = get();
+    if (!activeAiProvider) return;
+
+    await aiModelService.batchToggleAiModels(activeAiProvider, ids, enabled);
+    await get().refreshAiModelList();
+  },
+  batchUpdateAiModels: async (models) => {
+    const { activeAiProvider: id } = get();
+    if (!id) return;
+
+    await aiModelService.batchUpdateAiModels(id, models);
+    await get().refreshAiModelList();
+  },
+  clearRemoteModels: async (provider) => {
+    await aiModelService.clearRemoteModels(provider);
+    await get().refreshAiModelList();
+  },
+  createNewAiModel: async (data) => {
+    await aiModelService.createAiModel(data);
+    await get().refreshAiModelList();
+  },
+  fetchRemoteModelList: async (providerId) => {
+    const { modelsService } = await import('@/services/models');
+
+    const data = await modelsService.getChatModels(providerId);
+    if (data) {
+      await get().batchUpdateAiModels(
+        data.map((model) => ({
+          ...model,
+          abilities: {
+            files: model.files,
+            functionCall: model.functionCall,
+            vision: model.vision,
+          },
+          enabled: model.enabled || false,
+          source: 'remote',
+          type: 'chat',
+        })),
+      );
+
+      await get().refreshAiModelList();
+    }
+  },
+  internal_toggleAiModelLoading: (id, loading) => {
+    set(
+      (state) => {
+        if (loading) return { aiModelLoadingIds: [...state.aiModelLoadingIds, id] };
+
+        return { aiModelLoadingIds: state.aiModelLoadingIds.filter((i) => i !== id) };
+      },
+      false,
+      'toggleAiModelLoading',
+    );
+  },
+  refreshAiModelList: async () => {
+    await mutate([FETCH_AI_PROVIDER_MODEL_LIST_KEY, get().activeAiProvider]);
+    // make refresh provide runtime state async, not block
+    get().refreshAiProviderRuntimeState();
+  },
+  removeAiModel: async (id, providerId) => {
+    await aiModelService.deleteAiModel({ id, providerId });
+    await get().refreshAiModelList();
+  },
+  toggleModelEnabled: async (params) => {
+    const { activeAiProvider } = get();
+    if (!activeAiProvider) return;
+
+    get().internal_toggleAiModelLoading(params.id, true);
+
+    await aiModelService.toggleModelEnabled({ ...params, providerId: activeAiProvider });
+    await get().refreshAiModelList();
+
+    get().internal_toggleAiModelLoading(params.id, false);
+  },
+
+  updateAiModelsConfig: async (id, providerId, data) => {
+    await aiModelService.updateAiModel(id, providerId, data);
+    await get().refreshAiModelList();
+  },
+  updateAiModelsSort: async (id, items) => {
+    await aiModelService.updateAiModelOrder(id, items);
+    await get().refreshAiModelList();
+  },
+
+  useFetchAiProviderModels: (id) =>
+    useClientDataSWR<AiProviderModelListItem[]>(
+      [FETCH_AI_PROVIDER_MODEL_LIST_KEY, id],
+      ([, id]) => aiModelService.getAiProviderModelList(id as string),
+      {
+        onSuccess: (data) => {
+          // no need to update list if the list have been init and data is the same
+          if (get().isAiModelListInit && isEqual(data, get().aiProviderModelList)) return;
+
+          set(
+            { aiProviderModelList: data, isAiModelListInit: true },
+            false,
+            `useFetchAiProviderModels/${id}`,
+          );
+        },
+      },
+    ),
+});

package/src/store/aiInfra/slices/aiModel/index.ts

@@ -0,0 +1,3 @@
+export * from './action';
+export * from './initialState';
+export * from './selectors';

package/src/store/aiInfra/slices/aiModel/initialState.ts

@@ -0,0 +1,14 @@
+import { AiProviderModelListItem } from '@/types/aiModel';
+
+export interface AIModelsState {
+  aiModelLoadingIds: string[];
+  aiProviderModelList: AiProviderModelListItem[];
+  isAiModelListInit?: boolean;
+  modelSearchKeyword: string;
+}
+
+export const initialAIModelState: AIModelsState = {
+  aiModelLoadingIds: [],
+  aiProviderModelList: [],
+  modelSearchKeyword: '',
+};

package/src/store/aiInfra/slices/aiModel/selectors.ts

@@ -0,0 +1,63 @@
+import { AIProviderStoreState } from '@/store/aiInfra/initialState';
+import { AiModelSourceEnum } from '@/types/aiModel';
+
+// List
+const enabledAiProviderModelList = (s: AIProviderStoreState) =>
+  s.aiProviderModelList.filter((item) => item.enabled);
+
+const disabledAiProviderModelList = (s: AIProviderStoreState) =>
+  s.aiProviderModelList.filter((item) => !item.enabled);
+
+const filteredAiProviderModelList = (s: AIProviderStoreState) => {
+  const keyword = s.modelSearchKeyword.toLowerCase().trim();
+
+  return s.aiProviderModelList.filter(
+    (model) =>
+      model.id.toLowerCase().includes(keyword) ||
+      model.displayName?.toLowerCase().includes(keyword),
+  );
+};
+
+const totalAiProviderModelList = (s: AIProviderStoreState) => s.aiProviderModelList.length;
+const isEmptyAiProviderModelList = (s: AIProviderStoreState) => totalAiProviderModelList(s) === 0;
+
+const hasRemoteModels = (s: AIProviderStoreState) =>
+  s.aiProviderModelList.some((m) => m.source === AiModelSourceEnum.Remote);
+
+const isModelEnabled = (id: string) => (s: AIProviderStoreState) =>
+  enabledAiProviderModelList(s).some((i) => i.id === id);
+
+const isModelLoading = (id: string) => (s: AIProviderStoreState) =>
+  s.aiModelLoadingIds.includes(id);
+
+const getAiModelById = (id: string) => (s: AIProviderStoreState) =>
+  s.aiProviderModelList.find((i) => i.id === id);
+
+const getEnabledModelById = (id: string) => (s: AIProviderStoreState) =>
+  s.enabledAiModels?.find((i) => i.id === id);
+
+const isModelSupportToolUse = (id: string) => (s: AIProviderStoreState) => {
+  const model = getEnabledModelById(id)(s);
+
+  return model?.abilities?.functionCall;
+};
+
+const isModelSupportVision = (id: string) => (s: AIProviderStoreState) => {
+  const model = getEnabledModelById(id)(s);
+
+  return model?.abilities?.vision;
+};
+
+export const aiModelSelectors = {
+  disabledAiProviderModelList,
+  enabledAiProviderModelList,
+  filteredAiProviderModelList,
+  getAiModelById,
+  hasRemoteModels,
+  isEmptyAiProviderModelList,
+  isModelEnabled,
+  isModelLoading,
+  isModelSupportToolUse,
+  isModelSupportVision,
+  totalAiProviderModelList,
+};

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

@@ -0,0 +1,208 @@
+import { uniqBy } from 'lodash-es';
+import { SWRResponse, mutate } from 'swr';
+import { StateCreator } from 'zustand/vanilla';
+
+import { DEFAULT_MODEL_PROVIDER_LIST } from '@/config/modelProviders';
+import { isServerMode } from '@/const/version';
+import { useClientDataSWR } from '@/libs/swr';
+import { aiProviderService } from '@/services/aiProvider';
+import { AiInfraStore } from '@/store/aiInfra/store';
+import { ModelAbilities } from '@/types/aiModel';
+import {
+  AiProviderDetailItem,
+  AiProviderListItem,
+  AiProviderRuntimeState,
+  AiProviderSortMap,
+  AiProviderSourceEnum,
+  CreateAiProviderParams,
+  UpdateAiProviderConfigParams,
+  UpdateAiProviderParams,
+} from '@/types/aiProvider';
+
+enum AiProviderSwrKey {
+  fetchAiProviderItem = 'FETCH_AI_PROVIDER_ITEM',
+  fetchAiProviderList = 'FETCH_AI_PROVIDER',
+  fetchAiProviderRuntimeState = 'FETCH_AI_PROVIDER_RUNTIME_STATE',
+}
+
+export interface AiProviderAction {
+  createNewAiProvider: (params: CreateAiProviderParams) => Promise<void>;
+  deleteAiProvider: (id: string) => Promise<void>;
+  internal_toggleAiProviderLoading: (id: string, loading: boolean) => void;
+  refreshAiProviderDetail: () => Promise<void>;
+  refreshAiProviderList: () => Promise<void>;
+  refreshAiProviderRuntimeState: () => Promise<void>;
+  removeAiProvider: (id: string) => Promise<void>;
+  toggleProviderEnabled: (id: string, enabled: boolean) => Promise<void>;
+  updateAiProvider: (id: string, value: UpdateAiProviderParams) => Promise<void>;
+  updateAiProviderConfig: (id: string, value: UpdateAiProviderConfigParams) => Promise<void>;
+  updateAiProviderSort: (items: AiProviderSortMap[]) => Promise<void>;
+
+  useFetchAiProviderItem: (id: string) => SWRResponse<AiProviderDetailItem | undefined>;
+  useFetchAiProviderList: (params?: { suspense?: boolean }) => SWRResponse<AiProviderListItem[]>;
+  /**
+   * fetch provider keyVaults and user enabled model list
+   * @param isLoginOnInit
+   */
+  useFetchAiProviderRuntimeState: (
+    isLoginOnInit: boolean | undefined,
+  ) => SWRResponse<AiProviderRuntimeState | undefined>;
+}
+
+export const createAiProviderSlice: StateCreator<
+  AiInfraStore,
+  [['zustand/devtools', never]],
+  [],
+  AiProviderAction
+> = (set, get) => ({
+  createNewAiProvider: async (params) => {
+    await aiProviderService.createAiProvider({ ...params, source: AiProviderSourceEnum.Custom });
+    await get().refreshAiProviderList();
+  },
+  deleteAiProvider: async (id: string) => {
+    await aiProviderService.deleteAiProvider(id);
+
+    await get().refreshAiProviderList();
+  },
+  internal_toggleAiProviderLoading: (id, loading) => {
+    set(
+      (state) => {
+        if (loading) return { aiProviderLoadingIds: [...state.aiProviderLoadingIds, id] };
+
+        return { aiProviderLoadingIds: state.aiProviderLoadingIds.filter((i) => i !== id) };
+      },
+      false,
+      'toggleAiProviderLoading',
+    );
+  },
+  refreshAiProviderDetail: async () => {
+    await mutate([AiProviderSwrKey.fetchAiProviderItem, get().activeAiProvider]);
+    await get().refreshAiProviderRuntimeState();
+  },
+  refreshAiProviderList: async () => {
+    await mutate(AiProviderSwrKey.fetchAiProviderList);
+    await get().refreshAiProviderRuntimeState();
+  },
+  refreshAiProviderRuntimeState: async () => {
+    await mutate([AiProviderSwrKey.fetchAiProviderRuntimeState, true]);
+  },
+  removeAiProvider: async (id) => {
+    await aiProviderService.deleteAiProvider(id);
+    await get().refreshAiProviderList();
+  },
+
+  toggleProviderEnabled: async (id: string, enabled: boolean) => {
+    get().internal_toggleAiProviderLoading(id, true);
+    await aiProviderService.toggleProviderEnabled(id, enabled);
+    await get().refreshAiProviderList();
+
+    get().internal_toggleAiProviderLoading(id, false);
+  },
+
+  updateAiProvider: async (id, value) => {
+    get().internal_toggleAiProviderLoading(id, true);
+    await aiProviderService.updateAiProvider(id, value);
+    await get().refreshAiProviderList();
+    await get().refreshAiProviderDetail();
+
+    get().internal_toggleAiProviderLoading(id, false);
+  },
+
+  updateAiProviderConfig: async (id, value) => {
+    get().internal_toggleAiProviderLoading(id, true);
+    await aiProviderService.updateAiProviderConfig(id, value);
+    await get().refreshAiProviderDetail();
+
+    get().internal_toggleAiProviderLoading(id, false);
+  },
+
+  updateAiProviderSort: async (items) => {
+    await aiProviderService.updateAiProviderOrder(items);
+    await get().refreshAiProviderList();
+  },
+  useFetchAiProviderItem: (id) =>
+    useClientDataSWR<AiProviderDetailItem | undefined>(
+      [AiProviderSwrKey.fetchAiProviderItem, id],
+      () => aiProviderService.getAiProviderById(id),
+      {
+        onSuccess: (data) => {
+          if (!data) return;
+
+          set({ activeAiProvider: id, aiProviderDetail: data }, false, 'useFetchAiProviderItem');
+        },
+      },
+    ),
+  useFetchAiProviderList: () =>
+    useClientDataSWR<AiProviderListItem[]>(
+      AiProviderSwrKey.fetchAiProviderList,
+      () => aiProviderService.getAiProviderList(),
+      {
+        fallbackData: [],
+        onSuccess: (data) => {
+          if (!get().initAiProviderList) {
+            set(
+              { aiProviderList: data, initAiProviderList: true },
+              false,
+              'useFetchAiProviderList/init',
+            );
+            return;
+          }
+
+          set({ aiProviderList: data }, false, 'useFetchAiProviderList/refresh');
+        },
+      },
+    ),
+
+  useFetchAiProviderRuntimeState: (isLogin) =>
+    useClientDataSWR<AiProviderRuntimeState | undefined>(
+      isServerMode ? [AiProviderSwrKey.fetchAiProviderRuntimeState, isLogin] : null,
+      async ([, isLogin]) => {
+        if (isLogin) return aiProviderService.getAiProviderRuntimeState();
+
+        const { LOBE_DEFAULT_MODEL_LIST } = await import('@/config/aiModels');
+        return {
+          enabledAiModels: LOBE_DEFAULT_MODEL_LIST.filter((m) => m.enabled),
+          enabledAiProviders: DEFAULT_MODEL_PROVIDER_LIST.filter(
+            (provider) => provider.enabled,
+          ).map((item) => ({ id: item.id, name: item.name, source: 'builtin' })),
+          runtimeConfig: {},
+        };
+      },
+      {
+        onSuccess: (data) => {
+          if (!data) return;
+
+          const getModelListByType = (providerId: string, type: string) => {
+            const models = data.enabledAiModels
+              .filter((model) => model.providerId === providerId && model.type === type)
+              .map((model) => ({
+                abilities: (model.abilities || {}) as ModelAbilities,
+                contextWindowTokens: model.contextWindowTokens,
+                displayName: model.displayName ?? '',
+                id: model.id,
+              }));
+
+            return uniqBy(models, 'id');
+          };
+
+          // 3. 组装最终数据结构
+          const enabledChatModelList = data.enabledAiProviders.map((provider) => ({
+            ...provider,
+            children: getModelListByType(provider.id, 'chat'),
+            name: provider.name || provider.id,
+          }));
+
+          set(
+            {
+              aiProviderRuntimeConfig: data.runtimeConfig,
+              enabledAiModels: data.enabledAiModels,
+              enabledAiProviders: data.enabledAiProviders,
+              enabledChatModelList,
+            },
+            false,
+            'useInitAiProviderKeyVaults',
+          );
+        },
+      },
+    ),
+});

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

@@ -0,0 +1,3 @@
+export * from './action';
+export * from './initialState';
+export * from './selectors';

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

@@ -0,0 +1,32 @@
+import { EnabledProviderWithModels } from '@/types/aiModel';
+import {
+  AiProviderDetailItem,
+  AiProviderListItem,
+  AiProviderRuntimeConfig,
+  EnabledAiModel,
+  EnabledProvider,
+} from '@/types/aiProvider';
+
+export interface AIProviderState {
+  activeAiProvider?: string;
+  activeProviderModelList: any[];
+  aiProviderDetail?: AiProviderDetailItem | null;
+  aiProviderList: AiProviderListItem[];
+  aiProviderLoadingIds: string[];
+  aiProviderRuntimeConfig: Record<string, AiProviderRuntimeConfig>;
+  enabledAiModels?: EnabledAiModel[];
+  enabledAiProviders?: EnabledProvider[];
+  // used for select
+  enabledChatModelList?: EnabledProviderWithModels[];
+  initAiProviderList: boolean;
+  providerSearchKeyword: string;
+}
+
+export const initialAIProviderState: AIProviderState = {
+  activeProviderModelList: [],
+  aiProviderList: [],
+  aiProviderLoadingIds: [],
+  aiProviderRuntimeConfig: {},
+  initAiProviderList: false,
+  providerSearchKeyword: '',
+};