@lobehub/chat 1.45.5 → 1.45.7

package/src/utils/parseModels.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, it } from 'vitest';
 
-import { LOBE_DEFAULT_MODEL_LIST, OpenAIProviderCard } from '@/config/modelProviders';
-import { ChatModelCard } from '@/types/llm';
+import { LOBE_DEFAULT_MODEL_LIST } from '@/config/aiModels';
+import { openaiChatModels } from '@/config/aiModels/openai';
+import { AiFullModelCard } from '@/types/aiModel';
 
-import { parseModelString, transformToChatModelCards } from './parseModels';
+import { parseModelString, transformToAiChatModelList } from './parseModels';
 
 describe('parseModelString', () => {
   it('custom deletion, addition, and renaming of models', () => {
@@ -38,6 +39,8 @@ describe('parseModelString', () => {
         displayName: 'ChatGLM 6B',
         id: 'chatglm-6b',
         contextWindowTokens: 4096,
+        abilities: {},
+        type: 'chat',
       });
     });
 
@@ -46,9 +49,12 @@ describe('parseModelString', () => {
 
       expect(result.add[0]).toEqual({
         displayName: '讯飞星火 v3.5',
-        functionCall: true,
+        abilities: {
+          functionCall: true,
+        },
         id: 'spark-v3.5',
         contextWindowTokens: 8192,
+        type: 'chat',
       });
     });
 
@@ -60,15 +66,21 @@ describe('parseModelString', () => {
       expect(result.add).toEqual([
         {
           displayName: 'Gemini 1.5 Flash',
-          vision: true,
+          abilities: {
+            vision: true,
+          },
           id: 'gemini-1.5-flash-latest',
           contextWindowTokens: 16000,
+          type: 'chat',
         },
         {
           displayName: 'ChatGPT Plus',
-          vision: true,
-          functionCall: true,
-          files: true,
+          abilities: {
+            vision: true,
+            functionCall: true,
+            files: true,
+          },
+          type: 'chat',
           id: 'gpt-4-all',
           contextWindowTokens: 128000,
         },
@@ -82,100 +94,170 @@ describe('parseModelString', () => {
       expect(result.add).toEqual([
         {
           displayName: 'ChatGPT-4',
-          files: true,
-          functionCall: true,
+          abilities: {
+            functionCall: true,
+            files: true,
+          },
+          type: 'chat',
           id: 'gpt-4-0125-preview',
           contextWindowTokens: 128000,
         },
         {
           displayName: 'ChatGPT-4 Vision',
-          files: true,
-          functionCall: true,
+          abilities: {
+            functionCall: true,
+            files: true,
+            vision: true,
+          },
+          type: 'chat',
           id: 'gpt-4-turbo-2024-04-09',
           contextWindowTokens: 128000,
-          vision: true,
         },
       ]);
     });
 
     it('should handle empty extension capability value', () => {
       const result = parseModelString('model1<1024:>');
-      expect(result.add[0]).toEqual({ id: 'model1', contextWindowTokens: 1024 });
+      expect(result.add[0]).toEqual({
+        abilities: {},
+        type: 'chat',
+        id: 'model1',
+        contextWindowTokens: 1024,
+      });
     });
 
     it('should handle empty extension capability name', () => {
       const result = parseModelString('model1<1024::file>');
-      expect(result.add[0]).toEqual({ id: 'model1', contextWindowTokens: 1024, files: true });
+      expect(result.add[0]).toEqual({
+        id: 'model1',
+        contextWindowTokens: 1024,
+        abilities: {
+          files: true,
+        },
+        type: 'chat',
+      });
     });
 
     it('should handle duplicate extension capabilities', () => {
       const result = parseModelString('model1<1024:vision:vision>');
-      expect(result.add[0]).toEqual({ id: 'model1', contextWindowTokens: 1024, vision: true });
+      expect(result.add[0]).toEqual({
+        id: 'model1',
+        contextWindowTokens: 1024,
+        abilities: {
+          vision: true,
+        },
+        type: 'chat',
+      });
     });
 
     it('should handle case-sensitive extension capability names', () => {
       const result = parseModelString('model1<1024:VISION:FC:file>');
-      expect(result.add[0]).toEqual({ id: 'model1', contextWindowTokens: 1024, files: true });
+      expect(result.add[0]).toEqual({
+        id: 'model1',
+        contextWindowTokens: 1024,
+        abilities: {
+          files: true,
+        },
+        type: 'chat',
+      });
     });
 
     it('should handle case-sensitive extension capability values', () => {
       const result = parseModelString('model1<1024:vision:Fc:File>');
-      expect(result.add[0]).toEqual({ id: 'model1', contextWindowTokens: 1024, vision: true });
+      expect(result.add[0]).toEqual({
+        id: 'model1',
+        contextWindowTokens: 1024,
+        abilities: {
+          vision: true,
+        },
+        type: 'chat',
+      });
     });
 
     it('should handle empty angle brackets', () => {
       const result = parseModelString('model1<>');
-      expect(result.add[0]).toEqual({ id: 'model1' });
+      expect(result.add[0]).toEqual({ id: 'model1', abilities: {}, type: 'chat' });
     });
 
     it('should handle not close angle brackets', () => {
       const result = parseModelString('model1<,model2');
-      expect(result.add).toEqual([{ id: 'model1' }, { id: 'model2' }]);
+      expect(result.add).toEqual([
+        { id: 'model1', abilities: {}, type: 'chat' },
+        { id: 'model2', abilities: {}, type: 'chat' },
+      ]);
     });
 
     it('should handle multi close angle brackets', () => {
       const result = parseModelString('model1<>>,model2');
-      expect(result.add).toEqual([{ id: 'model1' }, { id: 'model2' }]);
+      expect(result.add).toEqual([
+        { id: 'model1', abilities: {}, type: 'chat' },
+        { id: 'model2', abilities: {}, type: 'chat' },
+      ]);
     });
 
     it('should handle only colon inside angle brackets', () => {
       const result = parseModelString('model1<:>');
-      expect(result.add[0]).toEqual({ id: 'model1' });
+      expect(result.add[0]).toEqual({ id: 'model1', abilities: {}, type: 'chat' });
     });
 
     it('should handle only non-digit characters inside angle brackets', () => {
       const result = parseModelString('model1<abc>');
-      expect(result.add[0]).toEqual({ id: 'model1' });
+      expect(result.add[0]).toEqual({ id: 'model1', abilities: {}, type: 'chat' });
     });
 
     it('should handle non-digit characters followed by digits inside angle brackets', () => {
       const result = parseModelString('model1<abc123>');
-      expect(result.add[0]).toEqual({ id: 'model1' });
+      expect(result.add[0]).toEqual({ id: 'model1', abilities: {}, type: 'chat' });
     });
 
     it('should handle digits followed by non-colon characters inside angle brackets', () => {
       const result = parseModelString('model1<1024abc>');
-      expect(result.add[0]).toEqual({ id: 'model1', contextWindowTokens: 1024 });
+      expect(result.add[0]).toEqual({
+        id: 'model1',
+        contextWindowTokens: 1024,
+        abilities: {},
+        type: 'chat',
+      });
     });
 
     it('should handle digits followed by multiple colons inside angle brackets', () => {
       const result = parseModelString('model1<1024::>');
-      expect(result.add[0]).toEqual({ id: 'model1', contextWindowTokens: 1024 });
+      expect(result.add[0]).toEqual({
+        id: 'model1',
+        contextWindowTokens: 1024,
+        abilities: {},
+        type: 'chat',
+      });
     });
 
     it('should handle digits followed by a colon and non-letter characters inside angle brackets', () => {
       const result = parseModelString('model1<1024:123>');
-      expect(result.add[0]).toEqual({ id: 'model1', contextWindowTokens: 1024 });
+      expect(result.add[0]).toEqual({
+        id: 'model1',
+        contextWindowTokens: 1024,
+        abilities: {},
+        type: 'chat',
+      });
     });
 
     it('should handle digits followed by a colon and spaces inside angle brackets', () => {
       const result = parseModelString('model1<1024: vision>');
-      expect(result.add[0]).toEqual({ id: 'model1', contextWindowTokens: 1024 });
+      expect(result.add[0]).toEqual({
+        id: 'model1',
+        contextWindowTokens: 1024,
+        abilities: {},
+        type: 'chat',
+      });
     });
 
     it('should handle digits followed by multiple colons and spaces inside angle brackets', () => {
       const result = parseModelString('model1<1024: : vision>');
-      expect(result.add[0]).toEqual({ id: 'model1', contextWindowTokens: 1024 });
+      expect(result.add[0]).toEqual({
+        id: 'model1',
+        contextWindowTokens: 1024,
+        abilities: {},
+        type: 'chat',
+      });
     });
   });
 
@@ -185,7 +267,11 @@ describe('parseModelString', () => {
       expect(result.add[0]).toEqual({
         id: 'model1',
         displayName: 'Model 1',
-        deploymentName: 'model1',
+        abilities: {},
+        type: 'chat',
+        config: {
+          deploymentName: 'model1',
+        },
       });
     });
 
@@ -194,48 +280,59 @@ describe('parseModelString', () => {
       expect(result.add[0]).toEqual({
         id: 'gpt-35-turbo',
         displayName: 'GPT 3.5 Turbo',
-        deploymentName: 'my-deploy',
+        abilities: {},
+        type: 'chat',
+        config: {
+          deploymentName: 'my-deploy',
+        },
       });
     });
   });
 });
 
 describe('transformToChatModelCards', () => {
-  const defaultChatModels: ChatModelCard[] = [
-    { id: 'model1', displayName: 'Model 1', enabled: true },
-    { id: 'model2', displayName: 'Model 2', enabled: false },
+  const defaultChatModels: AiFullModelCard[] = [
+    { id: 'model1', displayName: 'Model 1', enabled: true, type: 'chat' },
+    { id: 'model2', displayName: 'Model 2', enabled: false, type: 'chat' },
   ];
 
   it('should return undefined when modelString is empty', () => {
-    const result = transformToChatModelCards({
+    const result = transformToAiChatModelList({
       modelString: '',
       defaultChatModels,
+      providerId: 'openai',
     });
     expect(result).toBeUndefined();
   });
 
   it('should remove all models when removeAll is true', () => {
-    const result = transformToChatModelCards({
+    const result = transformToAiChatModelList({
       modelString: '-all',
       defaultChatModels,
+      providerId: 'openai',
     });
     expect(result).toEqual([]);
   });
 
   it('should remove specified models', () => {
-    const result = transformToChatModelCards({
+    const result = transformToAiChatModelList({
       modelString: '-model1',
       defaultChatModels,
+      providerId: 'openai',
     });
-    expect(result).toEqual([{ id: 'model2', displayName: 'Model 2', enabled: false }]);
+    expect(result).toEqual([
+      { id: 'model2', displayName: 'Model 2', enabled: false, type: 'chat' },
+    ]);
   });
 
   it('should add a new known model', () => {
-    const knownModel = LOBE_DEFAULT_MODEL_LIST[0];
-    const result = transformToChatModelCards({
+    const knownModel = LOBE_DEFAULT_MODEL_LIST.find((m) => m.providerId === 'ai21')!;
+    const result = transformToAiChatModelList({
       modelString: `${knownModel.id}`,
       defaultChatModels,
+      providerId: 'ai21',
     });
+
     expect(result).toContainEqual({
       ...knownModel,
       displayName: knownModel.displayName || knownModel.id,
@@ -244,31 +341,41 @@ describe('transformToChatModelCards', () => {
   });
 
   it('should update an existing known model', () => {
-    const knownModel = LOBE_DEFAULT_MODEL_LIST[0];
-    const result = transformToChatModelCards({
+    const knownModel = LOBE_DEFAULT_MODEL_LIST.find((m) => m.providerId === 'openai')!;
+    const result = transformToAiChatModelList({
       modelString: `+${knownModel.id}=Updated Model`,
       defaultChatModels: [knownModel],
+      providerId: 'openai',
+    });
+
+    expect(result).toContainEqual({
+      ...knownModel,
+      displayName: 'Updated Model',
+      enabled: true,
     });
-    expect(result![0]).toEqual({ ...knownModel, displayName: 'Updated Model', enabled: true });
   });
 
   it('should add a new custom model', () => {
-    const result = transformToChatModelCards({
+    const result = transformToAiChatModelList({
       modelString: '+custom_model=Custom Model',
       defaultChatModels,
+      providerId: 'openai',
     });
     expect(result).toContainEqual({
       id: 'custom_model',
       displayName: 'Custom Model',
       enabled: true,
+      abilities: {},
+      type: 'chat',
     });
   });
 
   it('should have file with builtin models like gpt-4-0125-preview', () => {
-    const result = transformToChatModelCards({
+    const result = transformToAiChatModelList({
       modelString:
         '-all,+gpt-4-0125-preview=ChatGPT-4<128000:fc:file>,+gpt-4-turbo-2024-04-09=ChatGPT-4 Vision<128000:fc:vision:file>',
-      defaultChatModels: OpenAIProviderCard.chatModels,
+      defaultChatModels: openaiChatModels,
+      providerId: 'openai',
     });
 
     expect(result).toMatchSnapshot();

package/src/utils/parseModels.ts

@@ -1,13 +1,14 @@
 import { produce } from 'immer';
 
-import { LOBE_DEFAULT_MODEL_LIST } from '@/config/modelProviders';
-import { ChatModelCard } from '@/types/llm';
+import { LOBE_DEFAULT_MODEL_LIST } from '@/config/aiModels';
+import { AiFullModelCard } from '@/types/aiModel';
+import { merge } from '@/utils/merge';
 
 /**
  * Parse model string to add or remove models.
  */
 export const parseModelString = (modelString: string = '', withDeploymentName = false) => {
-  let models: ChatModelCard[] = [];
+  let models: AiFullModelCard[] = [];
   let removeAll = false;
   const removedModels: string[] = [];
   const modelNames = modelString.split(/[,，]/).filter(Boolean);
@@ -45,13 +46,16 @@ export const parseModelString = (modelString: string = '', withDeploymentName =
       models.splice(existingIndex, 1);
     }
 
-    const model: ChatModelCard = {
+    const model: AiFullModelCard = {
+      abilities: {},
       displayName: displayName || undefined,
       id,
+      // TODO: 临时写死为 chat ，后续基于元数据迭代成对应的类型
+      type: 'chat',
     };
 
     if (deploymentName) {
-      model.deploymentName = deploymentName;
+      model.config = { deploymentName };
     }
 
     if (capabilities.length > 0) {
@@ -61,15 +65,15 @@ export const parseModelString = (modelString: string = '', withDeploymentName =
       for (const capability of capabilityList) {
         switch (capability) {
           case 'vision': {
-            model.vision = true;
+            model.abilities!.vision = true;
             break;
           }
           case 'fc': {
-            model.functionCall = true;
+            model.abilities!.functionCall = true;
             break;
           }
           case 'file': {
-            model.files = true;
+            model.abilities!.files = true;
             break;
           }
           default: {
@@ -92,15 +96,17 @@ export const parseModelString = (modelString: string = '', withDeploymentName =
 /**
  * Extract a special method to process chatModels
  */
-export const transformToChatModelCards = ({
+export const transformToAiChatModelList = ({
   modelString = '',
   defaultChatModels,
+  providerId,
   withDeploymentName = false,
 }: {
-  defaultChatModels: ChatModelCard[];
+  defaultChatModels: AiFullModelCard[];
   modelString?: string;
+  providerId: string;
   withDeploymentName?: boolean;
-}): ChatModelCard[] | undefined => {
+}): AiFullModelCard[] | undefined => {
   if (!modelString) return undefined;
 
   const modelConfig = parseModelString(modelString, withDeploymentName);
@@ -115,7 +121,14 @@ export const transformToChatModelCards = ({
     // 处理添加或替换逻辑
     for (const toAddModel of modelConfig.add) {
       // first try to find the model in LOBE_DEFAULT_MODEL_LIST to confirm if it is a known model
-      const knownModel = LOBE_DEFAULT_MODEL_LIST.find((model) => model.id === toAddModel.id);
+      let knownModel = LOBE_DEFAULT_MODEL_LIST.find(
+        (model) => model.id === toAddModel.id && model.providerId === providerId,
+      );
+
+      if (!knownModel) {
+        knownModel = LOBE_DEFAULT_MODEL_LIST.find((model) => model.id === toAddModel.id);
+        if (knownModel) knownModel.providerId = providerId;
+      }
 
       // if the model is known, update it based on the known model
       if (knownModel) {
@@ -124,20 +137,20 @@ export const transformToChatModelCards = ({
 
         // if the model is already in chatModels, update it
         if (modelInList) {
-          draft[index] = {
-            ...modelInList,
+          draft[index] = merge(modelInList, {
             ...toAddModel,
             displayName: toAddModel.displayName || modelInList.displayName || modelInList.id,
             enabled: true,
-          };
+          });
         } else {
           // if the model is not in chatModels, add it
-          draft.push({
-            ...knownModel,
-            ...toAddModel,
-            displayName: toAddModel.displayName || knownModel.displayName || knownModel.id,
-            enabled: true,
-          });
+          draft.push(
+            merge(knownModel, {
+              ...toAddModel,
+              displayName: toAddModel.displayName || knownModel.displayName || knownModel.id,
+              enabled: true,
+            }),
+          );
         }
       } else {
         // if the model is not in LOBE_DEFAULT_MODEL_LIST, add it as a new custom model

package/tests/setup-db.ts

@@ -1,7 +1,4 @@
 // import env
-import { Crypto } from '@peculiar/webcrypto';
 import * as dotenv from 'dotenv';
 
 dotenv.config();
-
-global.crypto = new Crypto();