@lobehub/chat 1.136.13 → 1.137.1

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

@@ -1,16 +1,335 @@
 // @vitest-environment node
 import { ModelProvider } from 'model-bank';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { testProvider } from '../../providerTestUtils';
-import { LobeStepfunAI } from './index';
+import { LobeStepfunAI, params } from './index';
 
 const provider = ModelProvider.Stepfun;
 const defaultBaseURL = 'https://api.stepfun.com/v1';
 
 testProvider({
   Runtime: LobeStepfunAI,
-  provider,
-  defaultBaseURL,
   chatDebugEnv: 'DEBUG_STEPFUN_CHAT_COMPLETION',
   chatModel: 'stepfun',
+  defaultBaseURL,
+  provider,
+  test: {
+    skipAPICall: true,
+  },
+});
+
+describe('LobeStepfunAI - custom features', () => {
+  let instance: InstanceType<typeof LobeStepfunAI>;
+
+  beforeEach(() => {
+    instance = new LobeStepfunAI({ apiKey: 'test_api_key' });
+    vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+      new ReadableStream() as any,
+    );
+  });
+
+  describe('params export', () => {
+    it('should export params with correct structure', () => {
+      expect(params).toBeDefined();
+      expect(params.provider).toBe(ModelProvider.Stepfun);
+      expect(params.baseURL).toBe('https://api.stepfun.com/v1');
+      expect(params.debug).toBeDefined();
+      expect(params.chatCompletion).toBeDefined();
+      expect(params.models).toBeDefined();
+    });
+
+    it('should have debug.chatCompletion function', () => {
+      expect(typeof params.debug?.chatCompletion).toBe('function');
+    });
+
+    it('should return false when DEBUG_STEPFUN_CHAT_COMPLETION is not set', () => {
+      delete process.env.DEBUG_STEPFUN_CHAT_COMPLETION;
+      expect(params.debug?.chatCompletion()).toBe(false);
+    });
+
+    it('should return true when DEBUG_STEPFUN_CHAT_COMPLETION is set to 1', () => {
+      process.env.DEBUG_STEPFUN_CHAT_COMPLETION = '1';
+      expect(params.debug?.chatCompletion()).toBe(true);
+      delete process.env.DEBUG_STEPFUN_CHAT_COMPLETION;
+    });
+  });
+
+  describe('handlePayload', () => {
+    it('should add web_search tool when enabledSearch is true', async () => {
+      await instance.chat({
+        enabledSearch: true,
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'step-1-8k',
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.tools).toContainEqual({
+        function: {
+          description: 'use web_search to search information on the internet',
+        },
+        type: 'web_search',
+      });
+    });
+
+    it('should merge web_search with existing tools', async () => {
+      await instance.chat({
+        enabledSearch: true,
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'step-1-8k',
+        tools: [{ function: { name: 'test' }, type: 'function' }],
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.tools).toHaveLength(2);
+      expect(calledPayload.tools[0]).toEqual({ function: { name: 'test' }, type: 'function' });
+      expect(calledPayload.tools[1]).toEqual({
+        function: {
+          description: 'use web_search to search information on the internet',
+        },
+        type: 'web_search',
+      });
+    });
+
+    it('should not add web_search tool when enabledSearch is false', async () => {
+      await instance.chat({
+        enabledSearch: false,
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'step-1-8k',
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.tools).toBeUndefined();
+    });
+
+    it('should not add web_search tool when enabledSearch is undefined', async () => {
+      await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'step-1-8k',
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.tools).toBeUndefined();
+    });
+
+    it('should preserve existing tools when enabledSearch is false', async () => {
+      await instance.chat({
+        enabledSearch: false,
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'step-1-8k',
+        tools: [{ function: { name: 'test' }, type: 'function' }],
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.tools).toHaveLength(1);
+      expect(calledPayload.tools[0]).toEqual({ function: { name: 'test' }, type: 'function' });
+    });
+
+    it('should set stream to false when tools are present', async () => {
+      await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'step-1-8k',
+        tools: [{ function: { name: 'test' }, type: 'function' }],
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.stream).toBe(false);
+    });
+
+    it('should set stream to false when web_search is enabled', async () => {
+      await instance.chat({
+        enabledSearch: true,
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'step-1-8k',
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.stream).toBe(false);
+    });
+
+    it('should set stream to true when no tools are present', async () => {
+      await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'step-1-8k',
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.stream).toBe(true);
+    });
+
+    it('should preserve other payload properties', async () => {
+      await instance.chat({
+        max_tokens: 100,
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'step-1-8k',
+        temperature: 0.7,
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.temperature).toBe(0.7);
+      expect(calledPayload.max_tokens).toBe(100);
+    });
+  });
+
+  describe('models function - keyword detection', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    it('should detect function call from step-1- keyword', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'step-1-8k' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should detect function call from step-1o- keyword', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'step-1o-8k' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should detect function call from step-1v- keyword', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'step-1v-8k' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should detect function call from step-2- keyword', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'step-2-16k' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should detect vision from step-1o- keyword', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'step-1o-8k' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should detect vision from step-r1-v- keyword', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'step-r1-v-8k' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should detect vision from step-1v- keyword', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'step-1v-8k' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should detect reasoning from step-r1- keyword', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'step-r1-8k' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should handle case-insensitive keyword matching', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'STEP-1-8K' }, { id: 'Step-R1-Turbo' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should handle models without matching keywords', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'other-model' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should merge abilities from known models', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [{ id: 'step-1-8k' }],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toBeDefined();
+    });
+
+    it('should handle empty model list', async () => {
+      const mockClient = {
+        models: {
+          list: vi.fn().mockResolvedValue({
+            data: [],
+          }),
+        },
+      };
+
+      const models = await params.models!({ client: mockClient as any });
+      expect(models).toEqual([]);
+    });
+  });
 });

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

@@ -1,13 +1,16 @@
 import type { ChatModelCard } from '@lobechat/types';
 import { ModelProvider } from 'model-bank';
 
-import { createOpenAICompatibleRuntime } from '../../core/openaiCompatibleFactory';
+import {
+  OpenAICompatibleFactoryOptions,
+  createOpenAICompatibleRuntime,
+} from '../../core/openaiCompatibleFactory';
 
 export interface StepfunModelCard {
   id: string;
 }
 
-export const LobeStepfunAI = createOpenAICompatibleRuntime({
+export const params = {
   baseURL: 'https://api.stepfun.com/v1',
   chatCompletion: {
     handlePayload: (payload) => {
@@ -76,4 +79,6 @@ export const LobeStepfunAI = createOpenAICompatibleRuntime({
       .filter(Boolean) as ChatModelCard[];
   },
   provider: ModelProvider.Stepfun,
-});
+} satisfies OpenAICompatibleFactoryOptions;
+
+export const LobeStepfunAI = createOpenAICompatibleRuntime(params);

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

@@ -1,13 +1,192 @@
 // @vitest-environment node
 import { ModelProvider } from 'model-bank';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { testProvider } from '../../providerTestUtils';
-import { LobeTencentCloudAI } from './index';
+import { LobeTencentCloudAI, TencentCloudModelCard, params } from './index';
 
+const provider = ModelProvider.TencentCloud;
+const defaultBaseURL = 'https://api.lkeap.cloud.tencent.com/v1';
+
+// Basic provider tests
 testProvider({
   Runtime: LobeTencentCloudAI,
-  provider: ModelProvider.TencentCloud,
-  defaultBaseURL: 'https://api.lkeap.cloud.tencent.com/v1',
+  bizErrorType: 'ProviderBizError',
   chatDebugEnv: 'DEBUG_TENCENT_CLOUD_CHAT_COMPLETION',
   chatModel: 'DeepSeek-R1',
+  defaultBaseURL,
+  invalidErrorType: 'InvalidProviderAPIKey',
+  provider,
+  test: {
+    skipAPICall: true,
+    skipErrorHandle: true,
+  },
+});
+
+// Custom feature tests
+describe('LobeTencentCloudAI - custom features', () => {
+  describe('params export', () => {
+    it('should export params object', () => {
+      expect(params).toBeDefined();
+      expect(params.baseURL).toBe(defaultBaseURL);
+      expect(params.provider).toBe(provider);
+    });
+
+    it('should have correct debug configuration', () => {
+      expect(params.debug?.chatCompletion).toBeDefined();
+
+      // Test debug = false
+      delete process.env.DEBUG_TENCENT_CLOUD_CHAT_COMPLETION;
+      expect(params.debug?.chatCompletion?.()).toBe(false);
+
+      // Test debug = true
+      process.env.DEBUG_TENCENT_CLOUD_CHAT_COMPLETION = '1';
+      expect(params.debug?.chatCompletion?.()).toBe(true);
+
+      // Cleanup
+      delete process.env.DEBUG_TENCENT_CLOUD_CHAT_COMPLETION;
+    });
+  });
+
+  describe('models function', () => {
+    let mockClient: any;
+
+    beforeEach(() => {
+      mockClient = {
+        models: {
+          list: vi.fn(),
+        },
+      };
+    });
+
+    it('should transform TencentCloud models to ChatModelCard format', async () => {
+      const mockModels: TencentCloudModelCard[] = [{ id: 'deepseek-r1' }, { id: 'gpt-4o-mini' }];
+
+      mockClient.models.list.mockResolvedValue({ data: mockModels });
+
+      const result = await params.models!({ client: mockClient });
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toMatchObject({
+        id: 'deepseek-r1',
+        reasoning: true, // Contains 'deepseek-r1' keyword
+      });
+      expect(result[1]).toMatchObject({
+        id: 'gpt-4o-mini',
+        reasoning: false,
+      });
+    });
+
+    it('should detect reasoning models by deepseek-r1 keyword', async () => {
+      const mockModels: TencentCloudModelCard[] = [
+        { id: 'deepseek-r1-distill' },
+        { id: 'deepseek-r1-pro' },
+      ];
+
+      mockClient.models.list.mockResolvedValue({ data: mockModels });
+
+      const result = await params.models!({ client: mockClient });
+
+      expect(result[0].reasoning).toBe(true);
+      expect(result[1].reasoning).toBe(true);
+    });
+
+    it('should use case-insensitive matching for deepseek-r1 keyword', async () => {
+      const mockModels: TencentCloudModelCard[] = [{ id: 'DEEPSEEK-R1-UPPER' }];
+
+      mockClient.models.list.mockResolvedValue({ data: mockModels });
+
+      const result = await params.models!({ client: mockClient });
+
+      expect(result[0].reasoning).toBe(true);
+    });
+
+    it('should handle models not in LOBE_DEFAULT_MODEL_LIST', async () => {
+      const mockModels: TencentCloudModelCard[] = [{ id: 'unknown-custom-model' }];
+
+      mockClient.models.list.mockResolvedValue({ data: mockModels });
+
+      const result = await params.models!({ client: mockClient });
+
+      expect(result[0]).toMatchObject({
+        contextWindowTokens: undefined,
+        displayName: undefined,
+        enabled: false,
+        functionCall: false,
+        id: 'unknown-custom-model',
+        reasoning: false,
+        vision: false,
+      });
+    });
+
+    it('should handle empty model list', async () => {
+      mockClient.models.list.mockResolvedValue({ data: [] });
+
+      const result = await params.models!({ client: mockClient });
+
+      expect(result).toEqual([]);
+    });
+
+    it('should get abilities from knownModel in LOBE_DEFAULT_MODEL_LIST', async () => {
+      const mockModels: TencentCloudModelCard[] = [{ id: 'gpt-4o' }];
+
+      mockClient.models.list.mockResolvedValue({ data: mockModels });
+
+      const result = await params.models!({ client: mockClient });
+
+      // Should get all abilities from knownModel if exists
+      expect(result[0]).toHaveProperty('functionCall');
+      expect(result[0]).toHaveProperty('vision');
+      expect(result[0]).toHaveProperty('reasoning');
+    });
+
+    it('should merge reasoning from keyword and knownModel abilities', async () => {
+      const mockModels: TencentCloudModelCard[] = [
+        { id: 'deepseek-r1' }, // Has keyword
+        { id: 'regular-model' }, // No keyword
+      ];
+
+      mockClient.models.list.mockResolvedValue({ data: mockModels });
+
+      const result = await params.models!({ client: mockClient });
+
+      // First model should have reasoning from keyword
+      expect(result[0].reasoning).toBe(true);
+
+      // Second model should not have reasoning (no keyword, not in default list with reasoning)
+      expect(result[1].reasoning).toBe(false);
+    });
+
+    it('should fallback to undefined for contextWindowTokens when not in known models', async () => {
+      const mockModels: TencentCloudModelCard[] = [{ id: 'unknown-model' }];
+
+      mockClient.models.list.mockResolvedValue({ data: mockModels });
+
+      const result = await params.models!({ client: mockClient });
+
+      expect(result[0].contextWindowTokens).toBeUndefined();
+    });
+
+    it('should fallback to false for enabled when not in known models', async () => {
+      const mockModels: TencentCloudModelCard[] = [{ id: 'unknown-model' }];
+
+      mockClient.models.list.mockResolvedValue({ data: mockModels });
+
+      const result = await params.models!({ client: mockClient });
+
+      expect(result[0].enabled).toBe(false);
+    });
+
+    it('should handle models without reasoning keyword', async () => {
+      const mockModels: TencentCloudModelCard[] = [{ id: 'claude-3-opus' }, { id: 'gemini-pro' }];
+
+      mockClient.models.list.mockResolvedValue({ data: mockModels });
+
+      const result = await params.models!({ client: mockClient });
+
+      // Both models should not have reasoning from keyword
+      expect(result[0].reasoning).toBe(false);
+      expect(result[1].reasoning).toBe(false);
+    });
+  });
 });

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

@@ -1,13 +1,16 @@
 import type { ChatModelCard } from '@lobechat/types';
 import { ModelProvider } from 'model-bank';
 
-import { createOpenAICompatibleRuntime } from '../../core/openaiCompatibleFactory';
+import {
+  OpenAICompatibleFactoryOptions,
+  createOpenAICompatibleRuntime,
+} from '../../core/openaiCompatibleFactory';
 
 export interface TencentCloudModelCard {
   id: string;
 }
 
-export const LobeTencentCloudAI = createOpenAICompatibleRuntime({
+export const params = {
   baseURL: 'https://api.lkeap.cloud.tencent.com/v1',
   debug: {
     chatCompletion: () => process.env.DEBUG_TENCENT_CLOUD_CHAT_COMPLETION === '1',
@@ -42,4 +45,6 @@ export const LobeTencentCloudAI = createOpenAICompatibleRuntime({
       .filter(Boolean) as ChatModelCard[];
   },
   provider: ModelProvider.TencentCloud,
-});
+} satisfies OpenAICompatibleFactoryOptions;
+
+export const LobeTencentCloudAI = createOpenAICompatibleRuntime(params);