@lobehub/chat 1.100.0 → 1.100.1

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

@@ -0,0 +1,235 @@
+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
+vi.mock('@/config/aiModels', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/config/aiModels')>();
+  return {
+    ...actual,
+    // Keep the original exports but we can override specific ones if needed
+  };
+});
+
+vi.mock('@/config/llm', () => ({
+  getLLMConfig: vi.fn(() => ({
+    ENABLED_OPENAI: true,
+    ENABLED_ANTHROPIC: false,
+    ENABLED_AI21: false,
+  })),
+}));
+
+vi.mock('@/utils/parseModels', () => ({
+  extractEnabledModels: vi.fn((providerId: string, modelString?: string) => {
+    if (!modelString) return undefined;
+    return [`${providerId}-model-1`, `${providerId}-model-2`];
+  }),
+  transformToAiModelList: vi.fn((params) => {
+    return params.defaultModels;
+  }),
+}));
+
+describe('genServerAiProvidersConfig', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Clear environment variables
+    Object.keys(process.env).forEach((key) => {
+      if (key.includes('MODEL_LIST')) {
+        delete process.env[key];
+      }
+    });
+  });
+
+  it('should generate basic provider config with default settings', () => {
+    const result = genServerAiProvidersConfig({});
+
+    expect(result).toHaveProperty('openai');
+    expect(result).toHaveProperty('anthropic');
+
+    expect(result.openai).toEqual({
+      enabled: true,
+      enabledModels: undefined,
+      serverModelLists: expect.any(Array),
+    });
+
+    expect(result.anthropic).toEqual({
+      enabled: false,
+      enabledModels: undefined,
+      serverModelLists: expect.any(Array),
+    });
+  });
+
+  it('should use custom enabled settings from specificConfig', () => {
+    const specificConfig = {
+      openai: {
+        enabled: false,
+      },
+      anthropic: {
+        enabled: true,
+      },
+    };
+
+    const result = genServerAiProvidersConfig(specificConfig);
+
+    expect(result.openai.enabled).toBe(false);
+    expect(result.anthropic.enabled).toBe(true);
+  });
+
+  it('should use custom enabledKey from specificConfig', async () => {
+    const specificConfig = {
+      openai: {
+        enabledKey: 'CUSTOM_OPENAI_ENABLED',
+      },
+    };
+
+    // Mock the LLM config to include our custom key
+    const { getLLMConfig } = vi.mocked(await import('@/config/llm'));
+    getLLMConfig.mockReturnValue({
+      ENABLED_OPENAI: true,
+      ENABLED_ANTHROPIC: false,
+      CUSTOM_OPENAI_ENABLED: true,
+    } as any);
+
+    const result = genServerAiProvidersConfig(specificConfig);
+
+    expect(result.openai.enabled).toBe(true);
+  });
+
+  it('should use environment variables for model lists', async () => {
+    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']);
+
+    const result = genServerAiProvidersConfig({});
+
+    expect(extractEnabledModels).toHaveBeenCalledWith('openai', '+gpt-4,+gpt-3.5-turbo', false);
+    expect(result.openai.enabledModels).toEqual(['gpt-4', 'gpt-3.5-turbo']);
+  });
+
+  it('should use custom modelListKey from specificConfig', async () => {
+    const specificConfig = {
+      openai: {
+        modelListKey: 'CUSTOM_OPENAI_MODELS',
+      },
+    };
+
+    process.env.CUSTOM_OPENAI_MODELS = '+custom-model';
+
+    const { extractEnabledModels } = vi.mocked(await import('@/utils/parseModels'));
+
+    genServerAiProvidersConfig(specificConfig);
+
+    expect(extractEnabledModels).toHaveBeenCalledWith('openai', '+custom-model', false);
+  });
+
+  it('should handle withDeploymentName option', async () => {
+    const specificConfig = {
+      openai: {
+        withDeploymentName: true,
+      },
+    };
+
+    process.env.OPENAI_MODEL_LIST = '+gpt-4->deployment1';
+
+    const { extractEnabledModels, transformToAiModelList } = vi.mocked(
+      await import('@/utils/parseModels'),
+    );
+
+    genServerAiProvidersConfig(specificConfig);
+
+    expect(extractEnabledModels).toHaveBeenCalledWith('openai', '+gpt-4->deployment1', true);
+    expect(transformToAiModelList).toHaveBeenCalledWith({
+      defaultModels: expect.any(Array),
+      modelString: '+gpt-4->deployment1',
+      providerId: 'openai',
+      withDeploymentName: true,
+    });
+  });
+
+  it('should include fetchOnClient when specified in config', () => {
+    const specificConfig = {
+      openai: {
+        fetchOnClient: true,
+      },
+    };
+
+    const result = genServerAiProvidersConfig(specificConfig);
+
+    expect(result.openai).toHaveProperty('fetchOnClient', true);
+  });
+
+  it('should not include fetchOnClient when not specified in config', () => {
+    const result = genServerAiProvidersConfig({});
+
+    expect(result.openai).not.toHaveProperty('fetchOnClient');
+  });
+
+  it('should handle all available providers', () => {
+    const result = genServerAiProvidersConfig({});
+
+    // Check that result includes some key providers
+    expect(result).toHaveProperty('openai');
+    expect(result).toHaveProperty('anthropic');
+
+    // Check structure for each provider
+    Object.keys(result).forEach((provider) => {
+      expect(result[provider]).toHaveProperty('enabled');
+      expect(result[provider]).toHaveProperty('serverModelLists');
+      // enabled can be boolean or undefined (when no config is provided)
+      expect(['boolean', 'undefined']).toContain(typeof result[provider].enabled);
+      expect(Array.isArray(result[provider].serverModelLists)).toBe(true);
+    });
+  });
+});
+
+describe('genServerAiProvidersConfig Error Handling', () => {
+  it('should throw error when a provider is not found in aiModels', async () => {
+    // Reset all mocks to create a clean test environment
+    vi.resetModules();
+
+    // Mock dependencies with a missing provider scenario
+    vi.doMock('@/config/aiModels', () => ({
+      // Explicitly set openai to undefined to simulate missing provider
+      openai: undefined,
+      anthropic: [
+        {
+          id: 'claude-3',
+          displayName: 'Claude 3',
+          type: 'chat',
+          enabled: true,
+        },
+      ],
+    }));
+
+    vi.doMock('@/config/llm', () => ({
+      getLLMConfig: vi.fn(() => ({})),
+    }));
+
+    vi.doMock('@/utils/parseModels', () => ({
+      extractEnabledModels: vi.fn(() => undefined),
+      transformToAiModelList: vi.fn(() => []),
+    }));
+
+    // Mock ModelProvider to include the missing provider
+    vi.doMock('@/libs/model-runtime', () => ({
+      ModelProvider: {
+        openai: 'openai', // This exists in enum
+        anthropic: 'anthropic', // This exists in both enum and aiModels
+      },
+    }));
+
+    // Import the function with the new mocks
+    const { genServerAiProvidersConfig } = await import(
+      './genServerAiProviderConfig?v=' + Date.now()
+    );
+
+    // This should throw because 'openai' is in ModelProvider but not in aiModels
+    expect(() => {
+      genServerAiProvidersConfig({});
+    }).toThrow();
+  });
+});

package/src/server/globalConfig/genServerAiProviderConfig.ts

@@ -3,7 +3,7 @@ import { getLLMConfig } from '@/config/llm';
 import { ModelProvider } from '@/libs/model-runtime';
 import { AiFullModelCard } from '@/types/aiModel';
 import { ProviderConfig } from '@/types/user/settings';
-import { extractEnabledModels, transformToAiChatModelList } from '@/utils/parseModels';
+import { extractEnabledModels, transformToAiModelList } from '@/utils/parseModels';
 
 interface ProviderSpecificConfig {
   enabled?: boolean;
@@ -19,19 +19,17 @@ export const genServerAiProvidersConfig = (specificConfig: Record<any, ProviderS
   return Object.values(ModelProvider).reduce(
     (config, provider) => {
       const providerUpperCase = provider.toUpperCase();
-      const providerCard = AiModels[provider] as AiFullModelCard[];
+      const aiModels = AiModels[provider] as AiFullModelCard[];
 
-      if (!providerCard)
+      if (!aiModels)
         throw new Error(
           `Provider [${provider}] not found in aiModels, please make sure you have exported the provider in the \`aiModels/index.ts\``,
         );
 
       const providerConfig = specificConfig[provider as keyof typeof specificConfig] || {};
-      const providerModelList =
+      const modelString =
         process.env[providerConfig.modelListKey ?? `${providerUpperCase}_MODEL_LIST`];
 
-      const defaultChatModels = providerCard.filter((c) => c.type === 'chat');
-
       config[provider] = {
         enabled:
           typeof providerConfig.enabled !== 'undefined'
@@ -39,12 +37,13 @@ export const genServerAiProvidersConfig = (specificConfig: Record<any, ProviderS
             : llmConfig[providerConfig.enabledKey || `ENABLED_${providerUpperCase}`],
 
         enabledModels: extractEnabledModels(
-          providerModelList,
+          provider,
+          modelString,
           providerConfig.withDeploymentName || false,
         ),
-        serverModelLists: transformToAiChatModelList({
-          defaultChatModels: defaultChatModels || [],
-          modelString: providerModelList,
+        serverModelLists: transformToAiModelList({
+          defaultModels: aiModels || [],
+          modelString,
           providerId: provider,
           withDeploymentName: providerConfig.withDeploymentName || false,
         }),

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

@@ -19,6 +19,7 @@ import {
   UpdateAiProviderConfigParams,
   UpdateAiProviderParams,
 } from '@/types/aiProvider';
+import { getModelPropertyWithFallback } from '@/utils/getFallbackModelProperty';
 
 enum AiProviderSwrKey {
   fetchAiProviderItem = 'FETCH_AI_PROVIDER_ITEM',
@@ -216,7 +217,7 @@ export const createAiProviderSlice: StateCreator<
                 ...(model.type === 'image' && {
                   parameters:
                     (model as AIImageModelCard).parameters ||
-                    LOBE_DEFAULT_MODEL_LIST.find((m) => m.id === model.id)?.parameters,
+                    getModelPropertyWithFallback(model.id, 'parameters'),
                 }),
               }));
 

package/src/utils/getFallbackModelProperty.test.ts

@@ -0,0 +1,193 @@
+import { vi } from 'vitest';
+
+import { getModelPropertyWithFallback } from './getFallbackModelProperty';
+
+// Mock LOBE_DEFAULT_MODEL_LIST for testing
+vi.mock('@/config/aiModels', () => ({
+  LOBE_DEFAULT_MODEL_LIST: [
+    {
+      id: 'gpt-4',
+      providerId: 'openai',
+      type: 'chat',
+      displayName: 'GPT-4',
+      contextWindowTokens: 8192,
+      enabled: true,
+      abilities: {
+        functionCall: true,
+        vision: true,
+      },
+      parameters: {
+        temperature: 0.7,
+        maxTokens: 4096,
+      },
+    },
+    {
+      id: 'gpt-4',
+      providerId: 'azure',
+      type: 'chat',
+      displayName: 'GPT-4 Azure',
+      contextWindowTokens: 8192,
+      enabled: true,
+      abilities: {
+        functionCall: true,
+      },
+    },
+    {
+      id: 'claude-3',
+      providerId: 'anthropic',
+      type: 'chat',
+      displayName: 'Claude 3',
+      contextWindowTokens: 200000,
+      enabled: false,
+    },
+    {
+      id: 'dall-e-3',
+      providerId: 'openai',
+      type: 'image',
+      displayName: 'DALL-E 3',
+      enabled: true,
+      parameters: {
+        size: '1024x1024',
+        quality: 'standard',
+      },
+    },
+  ],
+}));
+
+describe('getModelPropertyWithFallback', () => {
+  describe('when providerId is specified', () => {
+    it('should return exact match value when model exists with specified provider', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'displayName', 'openai');
+      expect(result).toBe('GPT-4');
+    });
+
+    it('should return exact match type when model exists with specified provider', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'type', 'openai');
+      expect(result).toBe('chat');
+    });
+
+    it('should return exact match contextWindowTokens when model exists with specified provider', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'contextWindowTokens', 'azure');
+      expect(result).toBe(8192);
+    });
+
+    it('should fall back to other provider when exact provider match not found', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'displayName', 'fake-provider');
+      expect(result).toBe('GPT-4'); // Falls back to openai provider
+    });
+
+    it('should return nested property like abilities', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'abilities', 'openai');
+      expect(result).toEqual({
+        functionCall: true,
+        vision: true,
+      });
+    });
+
+    it('should return parameters property correctly', () => {
+      const result = getModelPropertyWithFallback('dall-e-3', 'parameters', 'openai');
+      expect(result).toEqual({
+        size: '1024x1024',
+        quality: 'standard',
+      });
+    });
+  });
+
+  describe('when providerId is not specified', () => {
+    it('should return fallback match value when model exists', () => {
+      const result = getModelPropertyWithFallback('claude-3', 'displayName');
+      expect(result).toBe('Claude 3');
+    });
+
+    it('should return fallback match type when model exists', () => {
+      const result = getModelPropertyWithFallback('claude-3', 'type');
+      expect(result).toBe('chat');
+    });
+
+    it('should return fallback match enabled property', () => {
+      const result = getModelPropertyWithFallback('claude-3', 'enabled');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('when model is not found', () => {
+    it('should return default value "chat" for type property', () => {
+      const result = getModelPropertyWithFallback('non-existent-model', 'type');
+      expect(result).toBe('chat');
+    });
+
+    it('should return default value "chat" for type property even with providerId', () => {
+      const result = getModelPropertyWithFallback('non-existent-model', 'type', 'fake-provider');
+      expect(result).toBe('chat');
+    });
+
+    it('should return undefined for non-type properties when model not found', () => {
+      const result = getModelPropertyWithFallback('non-existent-model', 'displayName');
+      expect(result).toBeUndefined();
+    });
+
+    it('should return undefined for contextWindowTokens when model not found', () => {
+      const result = getModelPropertyWithFallback('non-existent-model', 'contextWindowTokens');
+      expect(result).toBeUndefined();
+    });
+
+    it('should return undefined for enabled property when model not found', () => {
+      const result = getModelPropertyWithFallback('non-existent-model', 'enabled');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('provider precedence logic', () => {
+    it('should prioritize exact provider match over general match', () => {
+      // gpt-4 exists in both openai and azure providers with different displayNames
+      const openaiResult = getModelPropertyWithFallback('gpt-4', 'displayName', 'openai');
+      const azureResult = getModelPropertyWithFallback('gpt-4', 'displayName', 'azure');
+
+      expect(openaiResult).toBe('GPT-4');
+      expect(azureResult).toBe('GPT-4 Azure');
+    });
+
+    it('should fall back to first match when specified provider not found', () => {
+      // When asking for 'fake-provider', should fall back to first match (openai)
+      const result = getModelPropertyWithFallback('gpt-4', 'displayName', 'fake-provider');
+      expect(result).toBe('GPT-4');
+    });
+  });
+
+  describe('property existence handling', () => {
+    it('should handle undefined properties gracefully', () => {
+      // claude-3 doesn't have abilities property defined
+      const result = getModelPropertyWithFallback('claude-3', 'abilities');
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle properties that exist but have falsy values', () => {
+      // claude-3 has enabled: false
+      const result = getModelPropertyWithFallback('claude-3', 'enabled');
+      expect(result).toBe(false);
+    });
+
+    it('should distinguish between undefined and null values', () => {
+      // Testing that we check for undefined specifically, not just falsy values
+      const result = getModelPropertyWithFallback('claude-3', 'contextWindowTokens');
+      expect(result).toBe(200000); // Should find the defined value
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty string modelId', () => {
+      const result = getModelPropertyWithFallback('', 'type');
+      expect(result).toBe('chat'); // Should fall back to default
+    });
+
+    it('should handle empty string providerId', () => {
+      const result = getModelPropertyWithFallback('gpt-4', 'type', '');
+      expect(result).toBe('chat'); // Should still find the model via fallback
+    });
+
+    it('should handle case-sensitive modelId correctly', () => {
+      const result = getModelPropertyWithFallback('GPT-4', 'type'); // Wrong case
+      expect(result).toBe('chat'); // Should fall back to default since no match
+    });
+  });
+});

package/src/utils/getFallbackModelProperty.ts

@@ -0,0 +1,36 @@
+import { LOBE_DEFAULT_MODEL_LIST } from '@/config/aiModels';
+import { AiFullModelCard } from '@/types/aiModel';
+
+/**
+ * Get the model property value, first from the specified provider, and then from other providers as a fallback.
+ * @param modelId The ID of the model.
+ * @param propertyName The name of the property.
+ * @param providerId Optional provider ID for an exact match.
+ * @returns The property value or a default value.
+ */
+export const getModelPropertyWithFallback = <T>(
+  modelId: string,
+  propertyName: keyof AiFullModelCard,
+  providerId?: string,
+): T => {
+  // Step 1: If providerId is provided, prioritize an exact match (same provider + same id)
+  if (providerId) {
+    const exactMatch = LOBE_DEFAULT_MODEL_LIST.find(
+      (m) => m.id === modelId && m.providerId === providerId,
+    );
+
+    if (exactMatch && exactMatch[propertyName] !== undefined) {
+      return exactMatch[propertyName] as T;
+    }
+  }
+
+  // Step 2: Fallback to a match ignoring the provider (match id only)
+  const fallbackMatch = LOBE_DEFAULT_MODEL_LIST.find((m) => m.id === modelId);
+
+  if (fallbackMatch && fallbackMatch[propertyName] !== undefined) {
+    return fallbackMatch[propertyName] as T;
+  }
+
+  // Step 3: Return a default value
+  return (propertyName === 'type' ? 'chat' : undefined) as T;
+};