@lobehub/chat 1.136.13 → 1.137.1

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

@@ -1,6 +1,9 @@
 import { ModelProvider } from 'model-bank';
 
-import { createOpenAICompatibleRuntime } from '../../core/openaiCompatibleFactory';
+import {
+  type OpenAICompatibleFactoryOptions,
+  createOpenAICompatibleRuntime,
+} from '../../core/openaiCompatibleFactory';
 import { processMultiProviderModelList } from '../../utils/modelParse';
 
 export interface VercelAIGatewayModelCard {
@@ -12,15 +15,15 @@ export interface VercelAIGatewayModelCard {
   name?: string;
   pricing?: {
     input?: string | number;
-    output?: string | number;
     input_cache_read?: string | number;
     input_cache_write?: string | number;
+    output?: string | number;
   };
   tags?: string[];
   type?: string;
 }
 
-const formatPrice = (price?: string | number) => {
+export const formatPrice = (price?: string | number) => {
   if (price === undefined || price === null) return undefined;
   const n = typeof price === 'number' ? price : Number(price);
   if (Number.isNaN(n)) return undefined;
@@ -28,21 +31,22 @@ const formatPrice = (price?: string | number) => {
   return Number((n * 1e6).toPrecision(5));
 };
 
-export const LobeVercelAIGatewayAI = createOpenAICompatibleRuntime({
+export const params = {
   baseURL: 'https://ai-gateway.vercel.sh/v1',
   chatCompletion: {
     handlePayload: (payload) => {
       const { model, reasoning_effort, verbosity, ...rest } = payload;
 
       const providerOptions: any = {};
-      if (reasoning_effort) {
-        providerOptions.openai = {
-          reasoningEffort: reasoning_effort,
-          reasoningSummary: 'auto',
-        };
-      }
-      if (verbosity) {
-        providerOptions.openai.textVerbosity = verbosity;
+      if (reasoning_effort || verbosity) {
+        providerOptions.openai = {};
+        if (reasoning_effort) {
+          providerOptions.openai.reasoningEffort = reasoning_effort;
+          providerOptions.openai.reasoningSummary = 'auto';
+        }
+        if (verbosity) {
+          providerOptions.openai.textVerbosity = verbosity;
+        }
       }
 
       return {
@@ -101,4 +105,6 @@ export const LobeVercelAIGatewayAI = createOpenAICompatibleRuntime({
     return await processMultiProviderModelList(formattedModels, 'vercelaigateway');
   },
   provider: ModelProvider.VercelAIGateway,
-});
+} satisfies OpenAICompatibleFactoryOptions;
+
+export const LobeVercelAIGatewayAI = createOpenAICompatibleRuntime(params);

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

@@ -1,8 +1,9 @@
 // @vitest-environment node
 import { ModelProvider } from 'model-bank';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { testProvider } from '../../providerTestUtils';
-import { LobeVLLMAI } from './index';
+import { LobeVLLMAI, VLLMModelCard } from './index';
 
 testProvider({
   Runtime: LobeVLLMAI,
@@ -11,3 +12,46 @@ testProvider({
   chatDebugEnv: 'DEBUG_VLLM_CHAT_COMPLETION',
   chatModel: 'llama-2-7b-chat',
 });
+
+describe('LobeVLLMAI - custom features', () => {
+  let instance: InstanceType<typeof LobeVLLMAI>;
+
+  beforeEach(() => {
+    instance = new LobeVLLMAI({ apiKey: 'test_api_key' });
+  });
+
+  describe('models', () => {
+    it('should fetch and process model list correctly', async () => {
+      const mockModelList: VLLMModelCard[] = [
+        { id: 'meta-llama/Llama-2-7b-chat-hf' },
+        { id: 'mistralai/Mistral-7B-Instruct-v0.1' },
+        { id: 'qwen/Qwen-7B-Chat' },
+      ];
+
+      vi.spyOn(instance['client'].models, 'list').mockResolvedValue({
+        data: mockModelList,
+      } as any);
+
+      const models = await instance.models();
+
+      expect(instance['client'].models.list).toHaveBeenCalled();
+      expect(models).toHaveLength(3);
+      expect(models[0]).toMatchObject({
+        id: 'meta-llama/Llama-2-7b-chat-hf',
+      });
+      expect(models[1]).toMatchObject({
+        id: 'mistralai/Mistral-7B-Instruct-v0.1',
+      });
+    });
+
+    it('should handle empty model list', async () => {
+      vi.spyOn(instance['client'].models, 'list').mockResolvedValue({
+        data: [],
+      } as any);
+
+      const models = await instance.models();
+
+      expect(models).toEqual([]);
+    });
+  });
+});

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

@@ -0,0 +1,75 @@
+// @vitest-environment node
+import { ModelProvider } from 'model-bank';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { testProvider } from '../../providerTestUtils';
+import { LobeVolcengineAI } from './index';
+
+testProvider({
+  Runtime: LobeVolcengineAI,
+  provider: ModelProvider.Volcengine,
+  defaultBaseURL: 'https://ark.cn-beijing.volces.com/api/v3',
+  chatDebugEnv: 'DEBUG_VOLCENGINE_CHAT_COMPLETION',
+  chatModel: 'doubao-pro-32k',
+  invalidErrorType: 'InvalidProviderAPIKey',
+  bizErrorType: 'ProviderBizError',
+  test: {
+    skipAPICall: true,
+    skipErrorHandle: true,
+  },
+});
+
+describe('LobeVolcengineAI - custom features', () => {
+  let instance: InstanceType<typeof LobeVolcengineAI>;
+
+  beforeEach(() => {
+    instance = new LobeVolcengineAI({ apiKey: 'test_api_key' });
+    vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+      new ReadableStream() as any,
+    );
+  });
+
+  describe('handlePayload', () => {
+    it('should add thinking for thinking-vision-pro model', async () => {
+      await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'thinking-vision-pro',
+        thinking: {
+          type: 'enabled',
+          budget_tokens: 1000,
+        },
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.thinking).toEqual({ type: 'enabled' });
+    });
+
+    it('should add thinking for deepseek-v3-1 model', async () => {
+      await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'deepseek-v3-1',
+        thinking: {
+          type: 'enabled',
+          budget_tokens: 2000,
+        },
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.thinking).toEqual({ type: 'enabled' });
+    });
+
+    it('should not add thinking for non-thinking models', async () => {
+      await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'doubao-pro-32k',
+        thinking: {
+          type: 'enabled',
+          budget_tokens: 1000,
+        },
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.thinking).toBeUndefined();
+    });
+  });
+});

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

@@ -4,7 +4,7 @@ import { ModelProvider } from 'model-bank';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { testProvider } from '../../providerTestUtils';
-import { LobeWenxinAI } from './index';
+import { LobeWenxinAI, params } from './index';
 
 testProvider({
   Runtime: LobeWenxinAI,
@@ -119,3 +119,146 @@ describe('LobeWenxinAI', () => {
     });
   });
 });
+
+describe('LobeWenxinAI - Custom Features', () => {
+  describe('Debug Configuration', () => {
+    it('should disable debug by default', () => {
+      delete process.env.DEBUG_WENXIN_CHAT_COMPLETION;
+      const result = params.debug.chatCompletion();
+      expect(result).toBe(false);
+    });
+
+    it('should enable debug when env is set to 1', () => {
+      process.env.DEBUG_WENXIN_CHAT_COMPLETION = '1';
+      const result = params.debug.chatCompletion();
+      expect(result).toBe(true);
+    });
+
+    it('should disable debug when env is set to other values', () => {
+      process.env.DEBUG_WENXIN_CHAT_COMPLETION = '0';
+      const result = params.debug.chatCompletion();
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('handlePayload', () => {
+    it('should transform payload without enabledSearch', () => {
+      const payload = {
+        model: 'ernie-4.0-8k',
+        messages: [{ role: 'user', content: 'Hello' }],
+        temperature: 0.7,
+      };
+
+      const result = params.chatCompletion!.handlePayload!(payload as any);
+
+      expect(result).toEqual({
+        model: 'ernie-4.0-8k',
+        messages: [{ role: 'user', content: 'Hello' }],
+        temperature: 0.7,
+        stream: true,
+      });
+      expect(result).not.toHaveProperty('web_search');
+    });
+
+    it('should transform payload with enabledSearch set to false', () => {
+      const payload = {
+        model: 'ernie-4.0-8k',
+        messages: [{ role: 'user', content: 'Hello' }],
+        temperature: 0.7,
+        enabledSearch: false,
+      };
+
+      const result = params.chatCompletion!.handlePayload!(payload as any);
+
+      expect(result).toEqual({
+        model: 'ernie-4.0-8k',
+        messages: [{ role: 'user', content: 'Hello' }],
+        temperature: 0.7,
+        stream: true,
+      });
+      expect(result).not.toHaveProperty('web_search');
+    });
+
+    it('should transform payload with enabledSearch set to true', () => {
+      const payload = {
+        model: 'ernie-4.0-8k',
+        messages: [{ role: 'user', content: 'Hello' }],
+        temperature: 0.7,
+        enabledSearch: true,
+      };
+
+      const result = params.chatCompletion!.handlePayload!(payload as any);
+
+      expect(result).toEqual({
+        model: 'ernie-4.0-8k',
+        messages: [{ role: 'user', content: 'Hello' }],
+        temperature: 0.7,
+        stream: true,
+        web_search: {
+          enable: true,
+          enable_citation: true,
+          enable_trace: true,
+        },
+      });
+    });
+
+    it('should add web_search config when enabledSearch is true', () => {
+      const payload = {
+        model: 'ernie-4.0-8k',
+        messages: [{ role: 'user', content: 'What is the weather today?' }],
+        enabledSearch: true,
+      };
+
+      const result = params.chatCompletion!.handlePayload!(payload as any);
+
+      expect(result.web_search).toEqual({
+        enable: true,
+        enable_citation: true,
+        enable_trace: true,
+      });
+    });
+
+    it('should preserve all original payload properties except enabledSearch', () => {
+      const payload = {
+        model: 'ernie-4.0-8k',
+        messages: [{ role: 'user', content: 'Hello' }],
+        temperature: 0.8,
+        max_tokens: 2048,
+        top_p: 0.9,
+        enabledSearch: true,
+        custom_field: 'test',
+      };
+
+      const result = params.chatCompletion!.handlePayload!(payload as any);
+
+      expect(result).toHaveProperty('model', 'ernie-4.0-8k');
+      expect(result).toHaveProperty('messages');
+      expect(result).toHaveProperty('temperature', 0.8);
+      expect(result).toHaveProperty('max_tokens', 2048);
+      expect(result).toHaveProperty('top_p', 0.9);
+      expect(result).toHaveProperty('custom_field', 'test');
+      expect(result).toHaveProperty('stream', true);
+      expect(result).toHaveProperty('web_search');
+      expect(result).not.toHaveProperty('enabledSearch');
+    });
+
+    it('should always set stream to true', () => {
+      const payloadWithoutStream = {
+        model: 'ernie-4.0-8k',
+        messages: [{ role: 'user', content: 'Hello' }],
+      };
+
+      const result1 = params.chatCompletion!.handlePayload!(payloadWithoutStream as any);
+      expect(result1.stream).toBe(true);
+
+      const payloadWithStreamFalse = {
+        model: 'ernie-4.0-8k',
+        messages: [{ role: 'user', content: 'Hello' }],
+        stream: false,
+      };
+
+      const result2 = params.chatCompletion!.handlePayload!(payloadWithStreamFalse as any);
+      expect(result2.stream).toBe(true);
+    });
+  });
+});

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

@@ -1,8 +1,11 @@
 import { ModelProvider } from 'model-bank';
 
-import { createOpenAICompatibleRuntime } from '../../core/openaiCompatibleFactory';
+import {
+  OpenAICompatibleFactoryOptions,
+  createOpenAICompatibleRuntime,
+} from '../../core/openaiCompatibleFactory';
 
-export const LobeWenxinAI = createOpenAICompatibleRuntime({
+export const params = {
   baseURL: 'https://qianfan.baidubce.com/v2',
   chatCompletion: {
     handlePayload: (payload) => {
@@ -25,4 +28,6 @@ export const LobeWenxinAI = createOpenAICompatibleRuntime({
     chatCompletion: () => process.env.DEBUG_WENXIN_CHAT_COMPLETION === '1',
   },
   provider: ModelProvider.Wenxin,
-});
+} satisfies OpenAICompatibleFactoryOptions;
+
+export const LobeWenxinAI = createOpenAICompatibleRuntime(params);

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

@@ -1,8 +1,9 @@
 // @vitest-environment node
 import { ModelProvider } from 'model-bank';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { testProvider } from '../../providerTestUtils';
-import { LobeXAI } from './index';
+import { LobeXAI, XAIModelCard, isGrokReasoningModel } from './index';
 
 testProvider({
   Runtime: LobeXAI,
@@ -11,3 +12,106 @@ testProvider({
   chatDebugEnv: 'DEBUG_XAI_CHAT_COMPLETION',
   chatModel: 'grok',
 });
+
+describe('LobeXAI - custom features', () => {
+  let instance: InstanceType<typeof LobeXAI>;
+
+  beforeEach(() => {
+    instance = new LobeXAI({ apiKey: 'test_api_key' });
+    vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+      new ReadableStream() as any,
+    );
+  });
+
+  describe('isGrokReasoningModel', () => {
+    it('should identify Grok reasoning models correctly', () => {
+      expect(isGrokReasoningModel('grok-3-mini')).toBe(true);
+      expect(isGrokReasoningModel('grok-4')).toBe(true);
+      expect(isGrokReasoningModel('grok-code')).toBe(true);
+      expect(isGrokReasoningModel('grok-2')).toBe(false);
+      expect(isGrokReasoningModel('other-model')).toBe(false);
+    });
+  });
+
+  describe('chat with handlePayload', () => {
+    it('should handle Grok reasoning models by removing frequency_penalty and presence_penalty', async () => {
+      await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'grok-4',
+        frequency_penalty: 0.5,
+        presence_penalty: 0.3,
+        temperature: 0.7,
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.frequency_penalty).toBeUndefined();
+      expect(calledPayload.presence_penalty).toBeUndefined();
+      expect(calledPayload.model).toBe('grok-4');
+    });
+
+    it('should keep frequency_penalty and presence_penalty for non-reasoning models', async () => {
+      await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'grok-2',
+        frequency_penalty: 0.5,
+        presence_penalty: 0.3,
+        temperature: 0.7,
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.frequency_penalty).toBe(0.5);
+      expect(calledPayload.presence_penalty).toBe(0.3);
+    });
+
+    it('should add search_parameters when enabledSearch is true', async () => {
+      process.env.XAI_MAX_SEARCH_RESULTS = '10';
+      process.env.XAI_SAFE_SEARCH = '1';
+
+      await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'grok-2',
+        enabledSearch: true,
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.search_parameters).toBeDefined();
+      expect(calledPayload.search_parameters.max_search_results).toBe(10);
+      expect(calledPayload.search_parameters.mode).toBe('auto');
+      expect(calledPayload.search_parameters.return_citations).toBe(true);
+      expect(calledPayload.search_parameters.sources).toHaveLength(3);
+
+      delete process.env.XAI_MAX_SEARCH_RESULTS;
+      delete process.env.XAI_SAFE_SEARCH;
+    });
+
+    it('should not add search_parameters when enabledSearch is false', async () => {
+      await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'grok-2',
+        enabledSearch: false,
+      });
+
+      const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
+      expect(calledPayload.search_parameters).toBeUndefined();
+    });
+  });
+
+  describe('models', () => {
+    it('should fetch and process model list correctly', async () => {
+      const mockModelList: XAIModelCard[] = [
+        { id: 'grok-2' },
+        { id: 'grok-3-mini' },
+        { id: 'grok-4' },
+      ];
+
+      vi.spyOn(instance['client'].models, 'list').mockResolvedValue({
+        data: mockModelList,
+      } as any);
+
+      const models = await instance.models();
+
+      expect(instance['client'].models.list).toHaveBeenCalled();
+      expect(models.length).toBeGreaterThan(0);
+    });
+  });
+});

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

@@ -1,8 +1,9 @@
 // @vitest-environment node
 import { ModelProvider } from 'model-bank';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { testProvider } from '../../providerTestUtils';
-import { LobeXinferenceAI } from './index';
+import { LobeXinferenceAI, XinferenceModelCard } from './index';
 
 testProvider({
   Runtime: LobeXinferenceAI,
@@ -11,3 +12,71 @@ testProvider({
   chatDebugEnv: 'DEBUG_XINFERENCE_CHAT_COMPLETION',
   chatModel: 'llama-2-7b-chat',
 });
+
+describe('LobeXinferenceAI - custom features', () => {
+  let instance: InstanceType<typeof LobeXinferenceAI>;
+
+  beforeEach(() => {
+    instance = new LobeXinferenceAI({ apiKey: 'test_api_key' });
+  });
+
+  describe('models', () => {
+    it('should fetch and process model list correctly', async () => {
+      const mockModelList: XinferenceModelCard[] = [
+        {
+          context_length: 4096,
+          id: 'qwen-7b',
+          model_ability: ['chat', 'tools', 'vision'],
+          model_description: 'Qwen 7B model',
+          model_type: 'LLM',
+          name: 'Qwen 7B',
+        },
+        {
+          context_length: 8192,
+          id: 'llama-2-13b',
+          model_ability: ['chat', 'reasoning'],
+          model_description: 'Llama 2 13B model',
+          model_type: 'LLM',
+          name: 'Llama 2 13B',
+        },
+      ];
+
+      vi.spyOn(instance['client'].models, 'list').mockResolvedValue({
+        data: mockModelList,
+      } as any);
+
+      const models = await instance.models();
+
+      expect(instance['client'].models.list).toHaveBeenCalled();
+      expect(models).toHaveLength(2);
+      expect(models[0]).toMatchObject({
+        id: 'qwen-7b',
+        displayName: 'Qwen 7B',
+        contextWindowTokens: 4096,
+        description: 'Qwen 7B model',
+        functionCall: true,
+        vision: true,
+        reasoning: false,
+      });
+      expect(models[1]).toMatchObject({
+        id: 'llama-2-13b',
+        displayName: 'Llama 2 13B',
+        contextWindowTokens: 8192,
+        description: 'Llama 2 13B model',
+        functionCall: false,
+        vision: false,
+        reasoning: true,
+      });
+    });
+
+    it('should handle empty model list', async () => {
+      vi.spyOn(instance['client'].models, 'list').mockResolvedValue({
+        data: [],
+      } as any);
+
+      const models = await instance.models();
+
+      expect(models).toEqual([]);
+    });
+  });
+});