@lobehub/chat 1.53.7 → 1.53.9

package/src/app/[variants]/(main)/settings/provider/features/ProviderConfig/Checker.tsx

@@ -1,18 +1,19 @@
 'use client';
 
 import { CheckCircleFilled } from '@ant-design/icons';
-import { Alert, Highlighter } from '@lobehub/ui';
-import { Button } from 'antd';
+import { ModelIcon } from '@lobehub/icons';
+import { Alert, Highlighter, Icon } from '@lobehub/ui';
+import { Button, Select, Space } from 'antd';
 import { useTheme } from 'antd-style';
+import { Loader2Icon } from 'lucide-react';
 import { ReactNode, memo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
 import { TraceNameMap } from '@/const/trace';
-import { useIsMobile } from '@/hooks/useIsMobile';
 import { useProviderName } from '@/hooks/useProviderName';
 import { chatService } from '@/services/chat';
-import { aiProviderSelectors, useAiInfraStore } from '@/store/aiInfra';
+import { aiModelSelectors, aiProviderSelectors, useAiInfraStore } from '@/store/aiInfra';
 import { ChatMessageError } from '@/types/message';
 
 const Error = memo<{ error: ChatMessageError }>(({ error }) => {
@@ -20,9 +21,8 @@ const Error = memo<{ error: ChatMessageError }>(({ error }) => {
   const providerName = useProviderName(error.body?.provider);
 
   return (
-    <Flexbox gap={8} style={{ maxWidth: '600px', width: '100%' }}>
+    <Flexbox gap={8} style={{ width: '100%' }}>
       <Alert
-        banner
         extra={
           <Flexbox>
             <Highlighter copyButtonSize={'small'} language={'json'} type={'pure'}>
@@ -54,10 +54,15 @@ const Checker = memo<ConnectionCheckerProps>(
   ({ model, provider, checkErrorRender: CheckErrorRender }) => {
     const { t } = useTranslation('setting');
 
-    const disabled = useAiInfraStore(aiProviderSelectors.isProviderConfigUpdating(provider));
+    const isProviderConfigUpdating = useAiInfraStore(
+      aiProviderSelectors.isProviderConfigUpdating(provider),
+    );
+    const totalModels = useAiInfraStore(aiModelSelectors.aiProviderChatModelListIds);
+    const updateAiProviderConfig = useAiInfraStore((s) => s.updateAiProviderConfig);
 
     const [loading, setLoading] = useState(false);
     const [pass, setPass] = useState(false);
+    const [checkModel, setCheckModel] = useState(model);
 
     const theme = useTheme();
     const [error, setError] = useState<ChatMessageError | undefined>();
@@ -71,6 +76,7 @@ const Checker = memo<ConnectionCheckerProps>(
           setPass(false);
           isError = true;
         },
+
         onFinish: async (value) => {
           if (!isError && value) {
             setError(undefined);
@@ -104,7 +110,6 @@ const Checker = memo<ConnectionCheckerProps>(
         },
       });
     };
-    const isMobile = useIsMobile();
 
     const defaultError = error ? <Error error={error as ChatMessageError} /> : null;
 
@@ -115,26 +120,42 @@ const Checker = memo<ConnectionCheckerProps>(
     );
 
     return (
-      <Flexbox align={isMobile ? 'flex-start' : 'flex-end'} gap={8}>
-        <Flexbox
-          align={'center'}
-          direction={isMobile ? 'horizontal-reverse' : 'horizontal'}
-          gap={12}
-        >
-          {pass && (
-            <Flexbox gap={4} horizontal>
-              <CheckCircleFilled
-                style={{
-                  color: theme.colorSuccess,
-                }}
-              />
-              {t('llm.checker.pass')}
-            </Flexbox>
-          )}
-          <Button disabled={disabled} loading={loading} onClick={checkConnection}>
+      <Flexbox gap={8}>
+        <Space.Compact block>
+          <Select
+            listItemHeight={36}
+            onSelect={async (value) => {
+              setCheckModel(value);
+              await updateAiProviderConfig(provider, { checkModel: value });
+            }}
+            optionRender={({ value }) => {
+              return (
+                <Flexbox align={'center'} gap={6} horizontal>
+                  <ModelIcon model={value as string} size={20} />
+                  {value}
+                </Flexbox>
+              );
+            }}
+            options={totalModels.map((id) => ({ label: id, value: id }))}
+            suffixIcon={isProviderConfigUpdating && <Icon icon={Loader2Icon} spin />}
+            value={checkModel}
+            virtual
+          />
+          <Button disabled={isProviderConfigUpdating} loading={loading} onClick={checkConnection}>
             {t('llm.checker.button')}
           </Button>
-        </Flexbox>
+        </Space.Compact>
+
+        {pass && (
+          <Flexbox gap={4} horizontal>
+            <CheckCircleFilled
+              style={{
+                color: theme.colorSuccess,
+              }}
+            />
+            {t('llm.checker.pass')}
+          </Flexbox>
+        )}
         {error && errorContent}
       </Flexbox>
     );

package/src/app/[variants]/(main)/settings/provider/features/ProviderConfig/index.tsx

@@ -275,7 +275,11 @@ const ProviderConfig = memo<ProviderConfigProps>(
             children: isLoading ? (
               <Skeleton.Button active />
             ) : (
-              <Checker checkErrorRender={checkErrorRender} model={checkModel!} provider={id} />
+              <Checker
+                checkErrorRender={checkErrorRender}
+                model={data?.checkModel || checkModel!}
+                provider={id}
+              />
             ),
             desc: t('providerModels.config.checker.desc'),
             label: t('providerModels.config.checker.title'),

package/src/config/modelProviders/spark.ts

@@ -69,7 +69,9 @@ const Spark: ModelProviderCard = {
   modelsUrl: 'https://xinghuo.xfyun.cn/spark',
   name: 'Spark',
   settings: {
+    modelEditable: false,
     sdkType: 'openai',
+    showModelFetcher: false,
     smoothing: {
       speed: 2,
       text: true,

package/src/const/version.ts

@@ -1,11 +1,10 @@
 import pkg from '@/../package.json';
-import { getServerDBConfig } from '@/config/db';
 
 import { BRANDING_NAME, ORG_NAME } from './branding';
 
 export const CURRENT_VERSION = pkg.version;
 
-export const isServerMode = getServerDBConfig().NEXT_PUBLIC_ENABLED_SERVER_SERVICE;
+export const isServerMode = process.env.NEXT_PUBLIC_SERVICE_MODE === 'server';
 export const isUsePgliteDB = process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite';
 
 export const isDeprecatedEdition = !isServerMode && !isUsePgliteDB;

package/src/database/server/models/aiModel.ts

@@ -197,6 +197,12 @@ export class AiModelModel {
       );
   }
 
+  clearModelsByProvider(providerId: string) {
+    return this.db
+      .delete(aiModels)
+      .where(and(eq(aiModels.providerId, providerId), eq(aiModels.userId, this.userId)));
+  }
+
   updateModelsOrder = async (providerId: string, sortMap: AiModelSortMap[]) => {
     await this.db.transaction(async (tx) => {
       const updates = sortMap.map(({ id, sort }) => {

package/src/locales/default/modelProvider.ts

@@ -278,6 +278,11 @@ export default {
         latestTime: '上次更新时间：{{time}}',
         noLatestTime: '暂未获取列表',
       },
+      resetAll: {
+        conform: '确认重置当前模型的所有修改？重置后当前模型列表将会回到默认状态',
+        success: '重置成功',
+        title: '重置所有修改',
+      },
       search: '搜索模型...',
       searchResult: '搜索到 {{count}} 个模型',
       title: '模型列表',

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

@@ -59,6 +59,11 @@ export const aiModelRouter = router({
       return ctx.aiModelModel.batchUpdateAiModels(input.id, input.models);
     }),
 
+  clearModelsByProvider: aiModelProcedure
+    .input(z.object({ providerId: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.aiModelModel.clearModelsByProvider(input.providerId);
+    }),
   clearRemoteModels: aiModelProcedure
     .input(z.object({ providerId: z.string() }))
     .mutation(async ({ input, ctx }) => {

package/src/services/aiModel/client.ts

@@ -47,6 +47,10 @@ export class ClientService extends BaseClientService implements IAiModelService
     return this.aiModel.clearRemoteModels(providerId);
   };
 
+  clearModelsByProvider: IAiModelService['clearModelsByProvider'] = async (providerId) => {
+    return this.aiModel.clearModelsByProvider(providerId);
+  };
+
   updateAiModelOrder: IAiModelService['updateAiModelOrder'] = async (providerId, items) => {
     return this.aiModel.updateModelsOrder(providerId, items);
   };

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

@@ -0,0 +1,122 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { lambdaClient } from '@/libs/trpc/client';
+import { AiProviderModelListItem } from '@/types/aiModel';
+
+import { ServerService } from './server';
+
+vi.mock('@/libs/trpc/client', () => ({
+  lambdaClient: {
+    aiModel: {
+      createAiModel: { mutate: vi.fn() },
+      getAiProviderModelList: { query: vi.fn() },
+      getAiModelById: { query: vi.fn() },
+      toggleModelEnabled: { mutate: vi.fn() },
+      updateAiModel: { mutate: vi.fn() },
+      batchUpdateAiModels: { mutate: vi.fn() },
+      batchToggleAiModels: { mutate: vi.fn() },
+      clearModelsByProvider: { mutate: vi.fn() },
+      clearRemoteModels: { mutate: vi.fn() },
+      updateAiModelOrder: { mutate: vi.fn() },
+      removeAiModel: { mutate: vi.fn() },
+    },
+  },
+}));
+
+describe('ServerService', () => {
+  const service = new ServerService();
+
+  it('should create AI model', async () => {
+    const params = {
+      id: 'test-id',
+      providerId: 'test-provider',
+      displayName: 'Test Model',
+    };
+    await service.createAiModel(params);
+    expect(vi.mocked(lambdaClient.aiModel.createAiModel.mutate)).toHaveBeenCalledWith(params);
+  });
+
+  it('should get AI provider model list', async () => {
+    await service.getAiProviderModelList('123');
+    expect(vi.mocked(lambdaClient.aiModel.getAiProviderModelList.query)).toHaveBeenCalledWith({
+      id: '123',
+    });
+  });
+
+  it('should get AI model by id', async () => {
+    await service.getAiModelById('123');
+    expect(vi.mocked(lambdaClient.aiModel.getAiModelById.query)).toHaveBeenCalledWith({
+      id: '123',
+    });
+  });
+
+  it('should toggle model enabled', async () => {
+    const params = { id: '123', providerId: 'test', enabled: true };
+    await service.toggleModelEnabled(params);
+    expect(vi.mocked(lambdaClient.aiModel.toggleModelEnabled.mutate)).toHaveBeenCalledWith(params);
+  });
+
+  it('should update AI model', async () => {
+    const value = { contextWindowTokens: 4000, displayName: 'Updated Model' };
+    await service.updateAiModel('123', 'openai', value);
+    expect(vi.mocked(lambdaClient.aiModel.updateAiModel.mutate)).toHaveBeenCalledWith({
+      id: '123',
+      providerId: 'openai',
+      value,
+    });
+  });
+
+  it('should batch update AI models', async () => {
+    const models: AiProviderModelListItem[] = [
+      {
+        id: '123',
+        enabled: true,
+        type: 'chat',
+      },
+    ];
+    await service.batchUpdateAiModels('provider1', models);
+    expect(vi.mocked(lambdaClient.aiModel.batchUpdateAiModels.mutate)).toHaveBeenCalledWith({
+      id: 'provider1',
+      models,
+    });
+  });
+
+  it('should batch toggle AI models', async () => {
+    const models = ['123', '456'];
+    await service.batchToggleAiModels('provider1', models, true);
+    expect(vi.mocked(lambdaClient.aiModel.batchToggleAiModels.mutate)).toHaveBeenCalledWith({
+      id: 'provider1',
+      models,
+      enabled: true,
+    });
+  });
+
+  it('should clear models by provider', async () => {
+    await service.clearModelsByProvider('provider1');
+    expect(vi.mocked(lambdaClient.aiModel.clearModelsByProvider.mutate)).toHaveBeenCalledWith({
+      providerId: 'provider1',
+    });
+  });
+
+  it('should clear remote models', async () => {
+    await service.clearRemoteModels('provider1');
+    expect(vi.mocked(lambdaClient.aiModel.clearRemoteModels.mutate)).toHaveBeenCalledWith({
+      providerId: 'provider1',
+    });
+  });
+
+  it('should update AI model order', async () => {
+    const items = [{ id: '123', sort: 1 }];
+    await service.updateAiModelOrder('provider1', items);
+    expect(vi.mocked(lambdaClient.aiModel.updateAiModelOrder.mutate)).toHaveBeenCalledWith({
+      providerId: 'provider1',
+      sortMap: items,
+    });
+  });
+
+  it('should delete AI model', async () => {
+    const params = { id: '123', providerId: 'openai' };
+    await service.deleteAiModel(params);
+    expect(vi.mocked(lambdaClient.aiModel.removeAiModel.mutate)).toHaveBeenCalledWith(params);
+  });
+});

package/src/services/aiModel/server.ts

@@ -30,6 +30,10 @@ export class ServerService implements IAiModelService {
     return lambdaClient.aiModel.batchToggleAiModels.mutate({ enabled, id, models });
   };
 
+  clearModelsByProvider: IAiModelService['clearModelsByProvider'] = async (providerId) => {
+    return lambdaClient.aiModel.clearModelsByProvider.mutate({ providerId });
+  };
+
   clearRemoteModels: IAiModelService['clearRemoteModels'] = async (providerId) => {
     return lambdaClient.aiModel.clearRemoteModels.mutate({ providerId });
   };

package/src/services/aiModel/type.ts

@@ -24,6 +24,8 @@ export interface IAiModelService {
 
   clearRemoteModels: (providerId: string) => Promise<any>;
 
+  clearModelsByProvider: (providerId: string) => Promise<any>;
+
   updateAiModelOrder: (providerId: string, items: AiModelSortMap[]) => Promise<any>;
 
   deleteAiModel: (params: { id: string; providerId: string }) => Promise<any>;

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

@@ -17,6 +17,7 @@ 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>;
+  clearModelsByProvider: (provider: string) => Promise<void>;
   clearRemoteModels: (provider: string) => Promise<void>;
   createNewAiModel: (params: CreateAiModelParams) => Promise<void>;
   fetchRemoteModelList: (providerId: string) => Promise<void>;
@@ -55,6 +56,10 @@ export const createAiModelSlice: StateCreator<
     await aiModelService.batchUpdateAiModels(id, models);
     await get().refreshAiModelList();
   },
+  clearModelsByProvider: async (provider) => {
+    await aiModelService.clearModelsByProvider(provider);
+    await get().refreshAiModelList();
+  },
   clearRemoteModels: async (provider) => {
     await aiModelService.clearRemoteModels(provider);
     await get().refreshAiModelList();

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

@@ -1,6 +1,8 @@
 import { AIProviderStoreState } from '@/store/aiInfra/initialState';
 import { AiModelSourceEnum } from '@/types/aiModel';
 
+const aiProviderChatModelListIds = (s: AIProviderStoreState) =>
+  s.aiProviderModelList.filter((item) => item.type === 'chat').map((item) => item.id);
 // List
 const enabledAiProviderModelList = (s: AIProviderStoreState) =>
   s.aiProviderModelList.filter((item) => item.enabled);
@@ -68,6 +70,7 @@ const modelContextWindowTokens = (id: string, provider: string) => (s: AIProvide
 };
 
 export const aiModelSelectors = {
+  aiProviderChatModelListIds,
   disabledAiProviderModelList,
   enabledAiProviderModelList,
   filteredAiProviderModelList,

package/src/types/aiProvider.ts

@@ -72,6 +72,13 @@ export interface AiProviderSettings {
    * @default false
    */
   disableBrowserRequest?: boolean;
+  /**
+   * whether provider support edit model
+   *
+   * @default true
+   */
+  modelEditable?: boolean;
+
   proxyUrl?:
     | {
         desc?: string;
@@ -84,7 +91,6 @@ export interface AiProviderSettings {
    * default openai
    */
   sdkType?: AiProviderSDKType;
-
   showAddNewModel?: boolean;
   /**
    * whether show api key in the provider config