@lobehub/chat 1.136.13 → 1.137.1

package/packages/model-runtime/src/providers/mistral/index.ts

@@ -1,7 +1,10 @@
 import type { ChatModelCard } from '@lobechat/types';
 import { ModelProvider } from 'model-bank';
 
-import { createOpenAICompatibleRuntime } from '../../core/openaiCompatibleFactory';
+import {
+  OpenAICompatibleFactoryOptions,
+  createOpenAICompatibleRuntime,
+} from '../../core/openaiCompatibleFactory';
 import { resolveParameters } from '../../core/parameterResolver';
 
 export interface MistralModelCard {
@@ -14,7 +17,7 @@ export interface MistralModelCard {
   max_context_length: number;
 }
 
-export const LobeMistralAI = createOpenAICompatibleRuntime({
+export const params = {
   baseURL: 'https://api.mistral.ai/v1',
   chatCompletion: {
     // Mistral API does not support stream_options: { include_usage: true }
@@ -66,4 +69,6 @@ export const LobeMistralAI = createOpenAICompatibleRuntime({
       .filter(Boolean) as ChatModelCard[];
   },
   provider: ModelProvider.Mistral,
-});
+} satisfies OpenAICompatibleFactoryOptions;
+
+export const LobeMistralAI = createOpenAICompatibleRuntime(params);

package/packages/model-runtime/src/providers/modelscope/index.test.ts

@@ -1,12 +1,14 @@
 // @vitest-environment node
 import { ModelProvider } from 'model-bank';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { testProvider } from '../../providerTestUtils';
-import { LobeModelScopeAI } from './index';
+import { LobeModelScopeAI, ModelScopeModelCard, params } from './index';
 
 const provider = ModelProvider.ModelScope;
 const defaultBaseURL = 'https://api-inference.modelscope.cn/v1';
 
+// Basic provider tests
 testProvider({
   Runtime: LobeModelScopeAI,
   provider,
@@ -17,3 +19,232 @@ testProvider({
     skipAPICall: true,
   },
 });
+
+// Custom feature tests
+describe('LobeModelScopeAI - custom features', () => {
+  describe('params export', () => {
+    it('should export params object', () => {
+      expect(params).toBeDefined();
+      expect(params.baseURL).toBe(defaultBaseURL);
+      expect(params.provider).toBe(provider);
+      expect(params.debug).toBeDefined();
+      expect(params.models).toBeDefined();
+    });
+  });
+
+  describe('debug configuration', () => {
+    it('should disable debug mode by default', () => {
+      delete process.env.DEBUG_MODELSCOPE_CHAT_COMPLETION;
+      const result = params.debug.chatCompletion();
+      expect(result).toBe(false);
+    });
+
+    it('should enable debug mode when env is set to 1', () => {
+      process.env.DEBUG_MODELSCOPE_CHAT_COMPLETION = '1';
+      const result = params.debug.chatCompletion();
+      expect(result).toBe(true);
+    });
+
+    it('should disable debug mode when env is not 1', () => {
+      process.env.DEBUG_MODELSCOPE_CHAT_COMPLETION = '0';
+      const result = params.debug.chatCompletion();
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('models function', () => {
+    let mockClient: any;
+    let consoleWarnSpy: any;
+
+    beforeEach(() => {
+      mockClient = {
+        models: {
+          list: vi.fn(),
+        },
+      };
+      consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    });
+
+    it('should fetch and process models successfully', async () => {
+      const mockModelData: ModelScopeModelCard[] = [
+        {
+          id: 'qwen2-7b-instruct',
+          object: 'model',
+          created: 1234567890,
+          owned_by: 'qwen',
+        },
+        {
+          id: 'qwen2.5-72b-instruct',
+          object: 'model',
+          created: 1234567891,
+          owned_by: 'qwen',
+        },
+      ];
+
+      mockClient.models.list.mockResolvedValue({
+        data: mockModelData,
+      });
+
+      const models = await params.models({ client: mockClient });
+
+      expect(mockClient.models.list).toHaveBeenCalledTimes(1);
+      expect(models).toBeDefined();
+      expect(Array.isArray(models)).toBe(true);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it('should handle empty model list', async () => {
+      mockClient.models.list.mockResolvedValue({
+        data: [],
+      });
+
+      const models = await params.models({ client: mockClient });
+
+      expect(mockClient.models.list).toHaveBeenCalledTimes(1);
+      expect(models).toBeDefined();
+      expect(Array.isArray(models)).toBe(true);
+      expect(models).toHaveLength(0);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it('should handle missing data field', async () => {
+      mockClient.models.list.mockResolvedValue({});
+
+      const models = await params.models({ client: mockClient });
+
+      expect(mockClient.models.list).toHaveBeenCalledTimes(1);
+      expect(models).toBeDefined();
+      expect(Array.isArray(models)).toBe(true);
+      expect(models).toHaveLength(0);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it('should handle API errors gracefully', async () => {
+      const mockError = new Error('API Error');
+      mockClient.models.list.mockRejectedValue(mockError);
+
+      const models = await params.models({ client: mockClient });
+
+      expect(mockClient.models.list).toHaveBeenCalledTimes(1);
+      expect(models).toEqual([]);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Failed to fetch ModelScope models. Please ensure your ModelScope API key is valid and your Alibaba Cloud account is properly bound:',
+        mockError,
+      );
+    });
+
+    it('should handle network errors', async () => {
+      const networkError = new Error('Network timeout');
+      mockClient.models.list.mockRejectedValue(networkError);
+
+      const models = await params.models({ client: mockClient });
+
+      expect(models).toEqual([]);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Failed to fetch ModelScope models. Please ensure your ModelScope API key is valid and your Alibaba Cloud account is properly bound:',
+        networkError,
+      );
+    });
+
+    it('should handle invalid API key errors', async () => {
+      const authError = new Error('Invalid API key');
+      mockClient.models.list.mockRejectedValue(authError);
+
+      const models = await params.models({ client: mockClient });
+
+      expect(models).toEqual([]);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Failed to fetch ModelScope models. Please ensure your ModelScope API key is valid and your Alibaba Cloud account is properly bound:',
+        authError,
+      );
+    });
+
+    it('should process models with processMultiProviderModelList', async () => {
+      const mockModelData: ModelScopeModelCard[] = [
+        {
+          id: 'qwen-plus',
+          object: 'model',
+          created: 1234567890,
+          owned_by: 'qwen',
+        },
+        {
+          id: 'qwen-turbo',
+          object: 'model',
+          created: 1234567891,
+          owned_by: 'qwen',
+        },
+      ];
+
+      mockClient.models.list.mockResolvedValue({
+        data: mockModelData,
+      });
+
+      const models = await params.models({ client: mockClient });
+
+      expect(models).toBeDefined();
+      expect(Array.isArray(models)).toBe(true);
+      // processMultiProviderModelList should process the models
+      expect(mockClient.models.list).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle models with different owned_by values', async () => {
+      const mockModelData: ModelScopeModelCard[] = [
+        {
+          id: 'model-1',
+          object: 'model',
+          created: 1234567890,
+          owned_by: 'provider-1',
+        },
+        {
+          id: 'model-2',
+          object: 'model',
+          created: 1234567891,
+          owned_by: 'provider-2',
+        },
+      ];
+
+      mockClient.models.list.mockResolvedValue({
+        data: mockModelData,
+      });
+
+      const models = await params.models({ client: mockClient });
+
+      expect(models).toBeDefined();
+      expect(Array.isArray(models)).toBe(true);
+    });
+  });
+
+  describe('ModelScopeModelCard interface', () => {
+    it('should have correct structure', () => {
+      const mockCard: ModelScopeModelCard = {
+        id: 'test-model',
+        object: 'model',
+        created: 1234567890,
+        owned_by: 'test-provider',
+      };
+
+      expect(mockCard.id).toBe('test-model');
+      expect(mockCard.object).toBe('model');
+      expect(mockCard.created).toBe(1234567890);
+      expect(mockCard.owned_by).toBe('test-provider');
+    });
+  });
+
+  describe('runtime instantiation', () => {
+    it('should create runtime instance with default config', () => {
+      const instance = new LobeModelScopeAI({ apiKey: 'test_api_key' });
+      expect(instance).toBeDefined();
+      expect(instance.baseURL).toBe(defaultBaseURL);
+    });
+
+    it('should create runtime instance with custom baseURL', () => {
+      const customBaseURL = 'https://custom.modelscope.cn/v1';
+      const instance = new LobeModelScopeAI({
+        apiKey: 'test_api_key',
+        baseURL: customBaseURL,
+      });
+      expect(instance).toBeDefined();
+      expect(instance.baseURL).toBe(customBaseURL);
+    });
+  });
+});

package/packages/model-runtime/src/providers/modelscope/index.ts

@@ -1,6 +1,9 @@
 import { ModelProvider } from 'model-bank';
 
-import { createOpenAICompatibleRuntime } from '../../core/openaiCompatibleFactory';
+import {
+  OpenAICompatibleFactoryOptions,
+  createOpenAICompatibleRuntime,
+} from '../../core/openaiCompatibleFactory';
 import { processMultiProviderModelList } from '../../utils/modelParse';
 
 export interface ModelScopeModelCard {
@@ -10,7 +13,7 @@ export interface ModelScopeModelCard {
   owned_by: string;
 }
 
-export const LobeModelScopeAI = createOpenAICompatibleRuntime({
+export const params = {
   baseURL: 'https://api-inference.modelscope.cn/v1',
   debug: {
     chatCompletion: () => process.env.DEBUG_MODELSCOPE_CHAT_COMPLETION === '1',
@@ -30,4 +33,6 @@ export const LobeModelScopeAI = createOpenAICompatibleRuntime({
     }
   },
   provider: ModelProvider.ModelScope,
-});
+} satisfies OpenAICompatibleFactoryOptions;
+
+export const LobeModelScopeAI = createOpenAICompatibleRuntime(params);