@lobehub/chat 1.108.0 → 1.108.2

package/src/libs/model-runtime/ppio/index.test.ts

@@ -1,13 +1,10 @@
 // @vitest-environment node
-import OpenAI from 'openai';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { LobeDeepSeekAI, LobeOpenAICompatibleRuntime } from '@/libs/model-runtime';
+import { LobeOpenAICompatibleRuntime } from '@/libs/model-runtime';
 import { ModelProvider } from '@/libs/model-runtime';
-import { AgentRuntimeErrorType } from '@/libs/model-runtime';
 import { testProvider } from '@/libs/model-runtime/providerTestUtils';
 
-import * as debugStreamModule from '../utils/debugStream';
 import models from './fixtures/models.json';
 import { LobePPIOAI } from './index';
 
@@ -30,7 +27,7 @@ let instance: LobeOpenAICompatibleRuntime;
 beforeEach(() => {
   instance = new LobePPIOAI({ apiKey: 'test' });
 
-  // 使用 vi.spyOn 来模拟 chat.completions.create 方法
+  // Use vi.spyOn to mock the chat.completions.create method
   vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
     new ReadableStream() as any,
   );
@@ -44,7 +41,7 @@ afterEach(() => {
 describe('PPIO', () => {
   describe('models', () => {
     it('should get models', async () => {
-      // mock the models.list method
+      // Mock the models.list method
       (instance['client'].models.list as Mock).mockResolvedValue({ data: models });
 
       const list = await instance.models();

package/src/libs/model-runtime/utils/openaiCompatibleFactory/index.ts

@@ -489,12 +489,14 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
           .filter(Boolean) as ChatModelCard[];
       }
 
-      return resultModels.map((model) => {
-        return {
-          ...model,
-          type: model.type || getModelPropertyWithFallback(model.id, 'type'),
-        };
-      }) as ChatModelCard[];
+      return (await Promise.all(
+        resultModels.map(async (model) => {
+          return {
+            ...model,
+            type: model.type || (await getModelPropertyWithFallback(model.id, 'type')),
+          };
+        }),
+      )) as ChatModelCard[];
     }
 
     async embeddings(

package/src/libs/next-auth/adapter/index.ts

@@ -4,7 +4,7 @@ import type {
   AdapterUser,
   VerificationToken,
 } from '@auth/core/adapters';
-import { and, eq } from 'drizzle-orm/expressions';
+import { and, eq } from 'drizzle-orm';
 import type { NeonDatabase } from 'drizzle-orm/neon-serverless';
 import { Adapter, AdapterAccount } from 'next-auth/adapters';
 

package/src/libs/oidc-provider/adapter.ts

@@ -1,6 +1,5 @@
 import debug from 'debug';
-import { sql } from 'drizzle-orm';
-import { eq } from 'drizzle-orm/expressions';
+import { eq, sql } from 'drizzle-orm';
 
 import {
   oidcAccessTokens,

package/src/server/globalConfig/genServerAiProviderConfig.test.ts

@@ -1,8 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { ModelProvider } from '@/libs/model-runtime';
-import { AiFullModelCard } from '@/types/aiModel';
-
 import { genServerAiProvidersConfig } from './genServerAiProviderConfig';
 
 // Mock dependencies using importOriginal to preserve real provider data
@@ -23,11 +20,11 @@ vi.mock('@/config/llm', () => ({
 }));
 
 vi.mock('@/utils/parseModels', () => ({
-  extractEnabledModels: vi.fn((providerId: string, modelString?: string) => {
+  extractEnabledModels: vi.fn(async (providerId: string, modelString?: string) => {
     if (!modelString) return undefined;
     return [`${providerId}-model-1`, `${providerId}-model-2`];
   }),
-  transformToAiModelList: vi.fn((params) => {
+  transformToAiModelList: vi.fn(async (params) => {
     return params.defaultModels;
   }),
 }));
@@ -43,8 +40,8 @@ describe('genServerAiProvidersConfig', () => {
     });
   });
 
-  it('should generate basic provider config with default settings', () => {
-    const result = genServerAiProvidersConfig({});
+  it('should generate basic provider config with default settings', async () => {
+    const result = await genServerAiProvidersConfig({});
 
     expect(result).toHaveProperty('openai');
     expect(result).toHaveProperty('anthropic');
@@ -62,7 +59,7 @@ describe('genServerAiProvidersConfig', () => {
     });
   });
 
-  it('should use custom enabled settings from specificConfig', () => {
+  it('should use custom enabled settings from specificConfig', async () => {
     const specificConfig = {
       openai: {
         enabled: false,
@@ -72,7 +69,7 @@ describe('genServerAiProvidersConfig', () => {
       },
     };
 
-    const result = genServerAiProvidersConfig(specificConfig);
+    const result = await genServerAiProvidersConfig(specificConfig);
 
     expect(result.openai.enabled).toBe(false);
     expect(result.anthropic.enabled).toBe(true);
@@ -93,7 +90,7 @@ describe('genServerAiProvidersConfig', () => {
       CUSTOM_OPENAI_ENABLED: true,
     } as any);
 
-    const result = genServerAiProvidersConfig(specificConfig);
+    const result = await genServerAiProvidersConfig(specificConfig);
 
     expect(result.openai.enabled).toBe(true);
   });
@@ -102,9 +99,9 @@ describe('genServerAiProvidersConfig', () => {
     process.env.OPENAI_MODEL_LIST = '+gpt-4,+gpt-3.5-turbo';
 
     const { extractEnabledModels } = vi.mocked(await import('@/utils/parseModels'));
-    extractEnabledModels.mockReturnValue(['gpt-4', 'gpt-3.5-turbo']);
+    extractEnabledModels.mockResolvedValue(['gpt-4', 'gpt-3.5-turbo']);
 
-    const result = genServerAiProvidersConfig({});
+    const result = await genServerAiProvidersConfig({});
 
     expect(extractEnabledModels).toHaveBeenCalledWith('openai', '+gpt-4,+gpt-3.5-turbo', false);
     expect(result.openai.enabledModels).toEqual(['gpt-4', 'gpt-3.5-turbo']);
@@ -121,7 +118,7 @@ describe('genServerAiProvidersConfig', () => {
 
     const { extractEnabledModels } = vi.mocked(await import('@/utils/parseModels'));
 
-    genServerAiProvidersConfig(specificConfig);
+    await genServerAiProvidersConfig(specificConfig);
 
     expect(extractEnabledModels).toHaveBeenCalledWith('openai', '+custom-model', false);
   });
@@ -139,7 +136,7 @@ describe('genServerAiProvidersConfig', () => {
       await import('@/utils/parseModels'),
     );
 
-    genServerAiProvidersConfig(specificConfig);
+    await genServerAiProvidersConfig(specificConfig);
 
     expect(extractEnabledModels).toHaveBeenCalledWith('openai', '+gpt-4->deployment1', true);
     expect(transformToAiModelList).toHaveBeenCalledWith({
@@ -150,26 +147,26 @@ describe('genServerAiProvidersConfig', () => {
     });
   });
 
-  it('should include fetchOnClient when specified in config', () => {
+  it('should include fetchOnClient when specified in config', async () => {
     const specificConfig = {
       openai: {
         fetchOnClient: true,
       },
     };
 
-    const result = genServerAiProvidersConfig(specificConfig);
+    const result = await genServerAiProvidersConfig(specificConfig);
 
     expect(result.openai).toHaveProperty('fetchOnClient', true);
   });
 
-  it('should not include fetchOnClient when not specified in config', () => {
-    const result = genServerAiProvidersConfig({});
+  it('should not include fetchOnClient when not specified in config', async () => {
+    const result = await genServerAiProvidersConfig({});
 
     expect(result.openai).not.toHaveProperty('fetchOnClient');
   });
 
-  it('should handle all available providers', () => {
-    const result = genServerAiProvidersConfig({});
+  it('should handle all available providers', async () => {
+    const result = await genServerAiProvidersConfig({});
 
     // Check that result includes some key providers
     expect(result).toHaveProperty('openai');
@@ -210,8 +207,8 @@ describe('genServerAiProvidersConfig Error Handling', () => {
     }));
 
     vi.doMock('@/utils/parseModels', () => ({
-      extractEnabledModels: vi.fn(() => undefined),
-      transformToAiModelList: vi.fn(() => []),
+      extractEnabledModels: vi.fn(async () => undefined),
+      transformToAiModelList: vi.fn(async () => []),
     }));
 
     // Mock ModelProvider to include the missing provider
@@ -228,8 +225,8 @@ describe('genServerAiProvidersConfig Error Handling', () => {
     );
 
     // This should throw because 'openai' is in ModelProvider but not in aiModels
-    expect(() => {
-      genServerAiProvidersConfig({});
-    }).toThrow();
+    await expect(async () => {
+      await genServerAiProvidersConfig({});
+    }).rejects.toThrow();
   });
 });

package/src/server/globalConfig/genServerAiProviderConfig.ts

@@ -13,11 +13,14 @@ interface ProviderSpecificConfig {
   withDeploymentName?: boolean;
 }
 
-export const genServerAiProvidersConfig = (specificConfig: Record<any, ProviderSpecificConfig>) => {
+export const genServerAiProvidersConfig = async (
+  specificConfig: Record<any, ProviderSpecificConfig>,
+) => {
   const llmConfig = getLLMConfig() as Record<string, any>;
 
-  return Object.values(ModelProvider).reduce(
-    (config, provider) => {
+  // 并发处理所有 providers
+  const providerConfigs = await Promise.all(
+    Object.values(ModelProvider).map(async (provider) => {
       const providerUpperCase = provider.toUpperCase();
       const aiModels = AiModels[provider] as AiFullModelCard[];
 
@@ -30,30 +33,39 @@ export const genServerAiProvidersConfig = (specificConfig: Record<any, ProviderS
       const modelString =
         process.env[providerConfig.modelListKey ?? `${providerUpperCase}_MODEL_LIST`];
 
-      config[provider] = {
-        enabled:
-          typeof providerConfig.enabled !== 'undefined'
-            ? providerConfig.enabled
-            : llmConfig[providerConfig.enabledKey || `ENABLED_${providerUpperCase}`],
-
-        enabledModels: extractEnabledModels(
-          provider,
-          modelString,
-          providerConfig.withDeploymentName || false,
-        ),
-        serverModelLists: transformToAiModelList({
+      // 并发处理 extractEnabledModels 和 transformToAiModelList
+      const [enabledModels, serverModelLists] = await Promise.all([
+        extractEnabledModels(provider, modelString, providerConfig.withDeploymentName || false),
+        transformToAiModelList({
           defaultModels: aiModels || [],
           modelString,
           providerId: provider,
           withDeploymentName: providerConfig.withDeploymentName || false,
         }),
-        ...(providerConfig.fetchOnClient !== undefined && {
-          fetchOnClient: providerConfig.fetchOnClient,
-        }),
-      };
+      ]);
 
-      return config;
-    },
-    {} as Record<string, ProviderConfig>,
+      return {
+        config: {
+          enabled:
+            typeof providerConfig.enabled !== 'undefined'
+              ? providerConfig.enabled
+              : llmConfig[providerConfig.enabledKey || `ENABLED_${providerUpperCase}`],
+          enabledModels,
+          serverModelLists,
+          ...(providerConfig.fetchOnClient !== undefined && {
+            fetchOnClient: providerConfig.fetchOnClient,
+          }),
+        },
+        provider,
+      };
+    }),
   );
+
+  // 将结果转换为对象
+  const config = {} as Record<string, ProviderConfig>;
+  for (const { provider, config: providerConfig } of providerConfigs) {
+    config[provider] = providerConfig;
+  }
+
+  return config;
 };

package/src/server/globalConfig/index.ts

@@ -17,7 +17,7 @@ export const getServerGlobalConfig = async () => {
   const { ACCESS_CODES, DEFAULT_AGENT_CONFIG } = getAppConfig();
 
   const config: GlobalServerConfig = {
-    aiProvider: genServerAiProvidersConfig({
+    aiProvider: await genServerAiProvidersConfig({
       azure: {
         enabledKey: 'ENABLED_AZURE_OPENAI',
         withDeploymentName: true,

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

@@ -1,5 +1,5 @@
 import { TRPCError } from '@trpc/server';
-import { inArray } from 'drizzle-orm/expressions';
+import { inArray } from 'drizzle-orm';
 import { z } from 'zod';
 
 import { DEFAULT_FILE_EMBEDDING_MODEL_ITEM } from '@/const/settings/knowledge';

package/src/server/services/discover/index.ts

@@ -6,8 +6,6 @@ import matter from 'gray-matter';
 import { cloneDeep, countBy, isString, merge, uniq, uniqBy } from 'lodash-es';
 import urlJoin from 'url-join';
 
-import { LOBE_DEFAULT_MODEL_LIST } from '@/config/aiModels';
-import { DEFAULT_MODEL_PROVIDER_LIST } from '@/config/modelProviders';
 import {
   DEFAULT_DISCOVER_ASSISTANT_ITEM,
   DEFAULT_DISCOVER_PLUGIN_ITEM,
@@ -728,6 +726,10 @@ export class DiscoverService {
 
   private _getProviderList = async (): Promise<DiscoverProviderItem[]> => {
     log('_getProviderList: fetching provider list');
+    const [{ LOBE_DEFAULT_MODEL_LIST }, { DEFAULT_MODEL_PROVIDER_LIST }] = await Promise.all([
+      import('@/config/aiModels'),
+      import('@/config/modelProviders'),
+    ]);
     const result = DEFAULT_MODEL_PROVIDER_LIST.map((item) => {
       const models = uniq(
         LOBE_DEFAULT_MODEL_LIST.filter((m) => m.providerId === item.id).map((m) => m.id),
@@ -751,6 +753,7 @@ export class DiscoverService {
   }): Promise<DiscoverProviderDetail | undefined> => {
     log('getProviderDetail: params=%O', params);
     const { identifier, locale, withReadme } = params;
+    const { LOBE_DEFAULT_MODEL_LIST } = await import('@/config/aiModels');
     const all = await this._getProviderList();
     let provider = all.find((item) => item.identifier === identifier);
     if (!provider) {
@@ -886,6 +889,7 @@ export class DiscoverService {
 
   private _getRawModelList = async (): Promise<DiscoverModelItem[]> => {
     log('_getRawModelList: fetching raw model list');
+    const { LOBE_DEFAULT_MODEL_LIST } = await import('@/config/aiModels');
     const result = LOBE_DEFAULT_MODEL_LIST.map((item) => {
       const identifier = (item.id.split('/').at(-1) || item.id).toLowerCase();
       const providers = uniq(
@@ -978,6 +982,7 @@ export class DiscoverService {
   getModelCategories = async (params: CategoryListQuery = {}): Promise<CategoryItem[]> => {
     log('getModelCategories: params=%O', params);
     const { q } = params;
+    const { LOBE_DEFAULT_MODEL_LIST } = await import('@/config/aiModels');
     let list = LOBE_DEFAULT_MODEL_LIST;
     if (q) {
       const originalCount = list.length;
@@ -1011,6 +1016,10 @@ export class DiscoverService {
     identifier: string;
   }): Promise<DiscoverModelDetail | undefined> => {
     log('getModelDetail: params=%O', params);
+    const [{ LOBE_DEFAULT_MODEL_LIST }, { DEFAULT_MODEL_PROVIDER_LIST }] = await Promise.all([
+      import('@/config/aiModels'),
+      import('@/config/modelProviders'),
+    ]);
     const { identifier } = params;
     const all = await this._getModelList();
     let model = all.find((item) => item.identifier.toLowerCase() === identifier.toLowerCase());

package/src/services/chat.ts

@@ -2,7 +2,6 @@ import { PluginRequestPayload, createHeadersWithPluginSettings } from '@lobehub/
 import { produce } from 'immer';
 import { merge } from 'lodash-es';
 
-import { DEFAULT_MODEL_PROVIDER_LIST } from '@/config/modelProviders';
 import { enableAuth } from '@/const/auth';
 import { INBOX_GUIDE_SYSTEMROLE } from '@/const/guide';
 import { INBOX_SESSION_ID } from '@/const/session';
@@ -404,6 +403,7 @@ class ChatService {
       provider,
     });
 
+    const { DEFAULT_MODEL_PROVIDER_LIST } = await import('@/config/modelProviders');
     const providerConfig = DEFAULT_MODEL_PROVIDER_LIST.find((item) => item.id === provider);
 
     let sdkType = provider;

package/src/services/session/client.test.ts

@@ -1,4 +1,4 @@
-import { eq, not } from 'drizzle-orm/expressions';
+import { eq, not } from 'drizzle-orm';
 import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { INBOX_SESSION_ID } from '@/const/session';

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

@@ -0,0 +1,211 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { EnabledAiModel, ModelAbilities } from '@/types/aiModel';
+
+import { getModelListByType } from '../action';
+
+// Mock getModelPropertyWithFallback
+vi.mock('@/utils/getFallbackModelProperty', () => ({
+  getModelPropertyWithFallback: vi.fn().mockReturnValue({ size: '1024x1024' }),
+}));
+
+describe('getModelListByType', () => {
+  const mockChatModels: EnabledAiModel[] = [
+    {
+      id: 'gpt-4',
+      providerId: 'openai',
+      type: 'chat',
+      abilities: { functionCall: true, files: true } as ModelAbilities,
+      contextWindowTokens: 8192,
+      displayName: 'GPT-4',
+      enabled: true,
+    },
+    {
+      id: 'gpt-3.5-turbo',
+      providerId: 'openai',
+      type: 'chat',
+      abilities: { functionCall: true } as ModelAbilities,
+      contextWindowTokens: 4096,
+      displayName: 'GPT-3.5 Turbo',
+      enabled: true,
+    },
+    {
+      id: 'claude-3-opus',
+      providerId: 'anthropic',
+      type: 'chat',
+      abilities: { functionCall: false, files: true } as ModelAbilities,
+      contextWindowTokens: 200000,
+      displayName: 'Claude 3 Opus',
+      enabled: true,
+    },
+  ];
+
+  const mockImageModels: EnabledAiModel[] = [
+    {
+      id: 'dall-e-3',
+      providerId: 'openai',
+      type: 'image',
+      abilities: {} as ModelAbilities,
+      displayName: 'DALL-E 3',
+      enabled: true,
+      parameters: { size: '1024x1024', quality: 'standard' },
+    },
+    {
+      id: 'midjourney',
+      providerId: 'midjourney',
+      type: 'image',
+      abilities: {} as ModelAbilities,
+      displayName: 'Midjourney',
+      enabled: true,
+    },
+  ];
+
+  const allModels = [...mockChatModels, ...mockImageModels];
+
+  describe('basic functionality', () => {
+    it('should filter models by providerId and type correctly', () => {
+      const result = getModelListByType(allModels, 'openai', 'chat');
+
+      expect(result).toHaveLength(2);
+      expect(result.map((m) => m.id)).toEqual(['gpt-4', 'gpt-3.5-turbo']);
+    });
+
+    it('should return correct model structure', () => {
+      const result = getModelListByType(allModels, 'openai', 'chat');
+
+      expect(result[0]).toEqual({
+        abilities: { functionCall: true, files: true },
+        contextWindowTokens: 8192,
+        displayName: 'GPT-4',
+        id: 'gpt-4',
+      });
+    });
+
+    it('should add parameters field for image models', () => {
+      const result = getModelListByType(allModels, 'openai', 'image');
+
+      expect(result[0]).toEqual({
+        abilities: {},
+        contextWindowTokens: undefined,
+        displayName: 'DALL-E 3',
+        id: 'dall-e-3',
+        parameters: { size: '1024x1024', quality: 'standard' },
+      });
+    });
+
+    it('should use fallback parameters for image models without parameters', () => {
+      const result = getModelListByType(allModels, 'midjourney', 'image');
+
+      expect(result[0]).toEqual({
+        abilities: {},
+        contextWindowTokens: undefined,
+        displayName: 'Midjourney',
+        id: 'midjourney',
+        parameters: { size: '1024x1024' },
+      });
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty model list', () => {
+      const result = getModelListByType([], 'openai', 'chat');
+      expect(result).toEqual([]);
+    });
+
+    it('should handle non-existent providerId', () => {
+      const result = getModelListByType(allModels, 'nonexistent', 'chat');
+      expect(result).toEqual([]);
+    });
+
+    it('should handle non-existent type', () => {
+      const result = getModelListByType(allModels, 'openai', 'nonexistent');
+      expect(result).toEqual([]);
+    });
+
+    it('should handle missing displayName', () => {
+      const modelsWithoutDisplayName: EnabledAiModel[] = [
+        {
+          id: 'test-model',
+          providerId: 'test',
+          type: 'chat',
+          abilities: {} as ModelAbilities,
+          enabled: true,
+        },
+      ];
+
+      const result = getModelListByType(modelsWithoutDisplayName, 'test', 'chat');
+      expect(result[0].displayName).toBe('');
+    });
+
+    it('should handle missing abilities', () => {
+      const modelsWithoutAbilities: EnabledAiModel[] = [
+        {
+          id: 'test-model',
+          providerId: 'test',
+          type: 'chat',
+          enabled: true,
+        } as EnabledAiModel,
+      ];
+
+      const result = getModelListByType(modelsWithoutAbilities, 'test', 'chat');
+      expect(result[0].abilities).toEqual({});
+    });
+  });
+
+  describe('deduplication', () => {
+    it('should remove duplicate model IDs', () => {
+      const duplicateModels: EnabledAiModel[] = [
+        {
+          id: 'gpt-4',
+          providerId: 'openai',
+          type: 'chat',
+          abilities: { functionCall: true } as ModelAbilities,
+          displayName: 'GPT-4 Version 1',
+          enabled: true,
+        },
+        {
+          id: 'gpt-4',
+          providerId: 'openai',
+          type: 'chat',
+          abilities: { functionCall: false } as ModelAbilities,
+          displayName: 'GPT-4 Version 2',
+          enabled: true,
+        },
+      ];
+
+      const result = getModelListByType(duplicateModels, 'openai', 'chat');
+
+      expect(result).toHaveLength(1);
+      expect(result[0].displayName).toBe('GPT-4 Version 1');
+    });
+  });
+
+  describe('type casting', () => {
+    it('should handle image model type casting correctly', () => {
+      const imageModel: EnabledAiModel[] = [
+        {
+          id: 'dall-e-3',
+          providerId: 'openai',
+          type: 'image',
+          abilities: {} as ModelAbilities,
+          displayName: 'DALL-E 3',
+          enabled: true,
+          parameters: { size: '1024x1024' },
+        } as any, // Simulate AIImageModelCard type
+      ];
+
+      const result = getModelListByType(imageModel, 'openai', 'image');
+
+      expect(result[0]).toHaveProperty('parameters');
+      expect(result[0].parameters).toEqual({ size: '1024x1024' });
+    });
+
+    it('should not add parameters field for non-image models', () => {
+      const result = getModelListByType(mockChatModels, 'openai', 'chat');
+
+      result.forEach((model) => {
+        expect(model).not.toHaveProperty('parameters');
+      });
+    });
+  });
+});