@lobehub/chat 1.73.2 → 1.74.0

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

@@ -1,10 +1,11 @@
- // @vitest-environment node
+// @vitest-environment node
 import OpenAI from 'openai';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
+import { LobeDeepSeekAI, LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
 import { ModelProvider } from '@/libs/agent-runtime';
 import { AgentRuntimeErrorType } from '@/libs/agent-runtime';
+import { testProvider } from '@/libs/agent-runtime/providerTestUtils';
 
 import * as debugStreamModule from '../utils/debugStream';
 import models from './fixtures/models.json';
@@ -12,8 +13,14 @@ import { LobePPIOAI } from './index';
 
 const provider = ModelProvider.PPIO;
 const defaultBaseURL = 'https://api.ppinfra.com/v3/openai';
-const bizErrorType = AgentRuntimeErrorType.ProviderBizError;
-const invalidErrorType = AgentRuntimeErrorType.InvalidProviderAPIKey;
+
+testProvider({
+  Runtime: LobePPIOAI,
+  provider,
+  defaultBaseURL,
+  chatDebugEnv: 'DEBUG_PPIO_CHAT_COMPLETION',
+  chatModel: 'deepseek-r1',
+});
 
 // Mock the console.error to avoid polluting test output
 vi.spyOn(console, 'error').mockImplementation(() => {});
@@ -35,222 +42,6 @@ afterEach(() => {
 });
 
 describe('PPIO', () => {
-  describe('init', () => {
-    it('should correctly initialize with an API key', async () => {
-      const instance = new LobePPIOAI({ apiKey: 'test_api_key' });
-      expect(instance).toBeInstanceOf(LobePPIOAI);
-      expect(instance.baseURL).toEqual(defaultBaseURL);
-    });
-  });
-
-  describe('chat', () => {
-    describe('Error', () => {
-      it('should return Error with an openai error response when OpenAI.APIError is thrown', async () => {
-        // Arrange
-        const apiError = new OpenAI.APIError(
-          400,
-          {
-            status: 400,
-            error: {
-              message: 'Bad Request',
-            },
-          },
-          'Error message',
-          {},
-        );
-
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
-
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'meta-llama/llama-3-8b-instruct',
-            temperature: 0.999,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: {
-              error: { message: 'Bad Request' },
-              status: 400,
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should throw AgentRuntimeError if no apiKey is provided', async () => {
-        try {
-          new LobePPIOAI({});
-        } catch (e) {
-          expect(e).toEqual({ errorType: invalidErrorType });
-        }
-      });
-
-      it('should return Error with the cause when OpenAI.APIError is thrown with cause', async () => {
-        // Arrange
-        const errorInfo = {
-          stack: 'abc',
-          cause: {
-            message: 'api is undefined',
-          },
-        };
-        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
-
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
-
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'meta-llama/llama-3-8b-instruct',
-            temperature: 0.999,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: {
-              cause: { message: 'api is undefined' },
-              stack: 'abc',
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should return Error with an cause response with desensitize Url', async () => {
-        // Arrange
-        const errorInfo = {
-          stack: 'abc',
-          cause: { message: 'api is undefined' },
-        };
-        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
-
-        instance = new LobePPIOAI({
-          apiKey: 'test',
-
-          baseURL: 'https://api.abc.com/v1',
-        });
-
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
-
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'meta-llama/llama-3-8b-instruct',
-            temperature: 0.999,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: 'https://api.***.com/v1',
-            error: {
-              cause: { message: 'api is undefined' },
-              stack: 'abc',
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should throw an error type on 401 status code', async () => {
-        // Mock the API call to simulate a 401 error
-        const error = new Error('InvalidApiKey') as any;
-        error.status = 401;
-        vi.mocked(instance['client'].chat.completions.create).mockRejectedValue(error);
-
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'meta-llama/llama-3-8b-instruct',
-            temperature: 0.999,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: new Error('InvalidApiKey'),
-            errorType: invalidErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should return AgentRuntimeError for non-OpenAI errors', async () => {
-        // Arrange
-        const genericError = new Error('Generic Error');
-
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(genericError);
-
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'meta-llama/llama-3-8b-instruct',
-            temperature: 0.999,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            errorType: 'AgentRuntimeError',
-            provider,
-            error: {
-              name: genericError.name,
-              cause: genericError.cause,
-              message: genericError.message,
-              stack: genericError.stack,
-            },
-          });
-        }
-      });
-    });
-
-    describe('DEBUG', () => {
-      it('should call debugStream and return StreamingTextResponse when DEBUG_PPIO_CHAT_COMPLETION is 1', async () => {
-        // Arrange
-        const mockProdStream = new ReadableStream() as any; // 模拟的 prod 流
-        const mockDebugStream = new ReadableStream({
-          start(controller) {
-            controller.enqueue('Debug stream content');
-            controller.close();
-          },
-        }) as any;
-        mockDebugStream.toReadableStream = () => mockDebugStream; // 添加 toReadableStream 方法
-
-        // 模拟 chat.completions.create 返回值，包括模拟的 tee 方法
-        (instance['client'].chat.completions.create as Mock).mockResolvedValue({
-          tee: () => [mockProdStream, { toReadableStream: () => mockDebugStream }],
-        });
-
-        // 保存原始环境变量值
-        const originalDebugValue = process.env.DEBUG_PPIO_CHAT_COMPLETION;
-
-        // 模拟环境变量
-        process.env.DEBUG_PPIO_CHAT_COMPLETION = '1';
-        vi.spyOn(debugStreamModule, 'debugStream').mockImplementation(() => Promise.resolve());
-
-        // 执行测试
-        // 运行你的测试函数，确保它会在条件满足时调用 debugStream
-        // 假设的测试函数调用，你可能需要根据实际情况调整
-        await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'meta-llama/llama-3-8b-instruct',
-          stream: true,
-          temperature: 0.999,
-        });
-
-        // 验证 debugStream 被调用
-        expect(debugStreamModule.debugStream).toHaveBeenCalled();
-
-        // 恢复原始环境变量值
-        process.env.DEBUG_PPIO_CHAT_COMPLETION = originalDebugValue;
-      });
-    });
-  });
-
   describe('models', () => {
     it('should get models', async () => {
       // mock the models.list method

package/src/libs/agent-runtime/providerTestUtils.ts

@@ -111,7 +111,7 @@ export const testProvider = ({
       }
 
       describe('Error', () => {
-        it('should return OpenAIBizError with an openai error response when OpenAI.APIError is thrown', async () => {
+        it('should return ProviderBizError with an openai error response when OpenAI.APIError is thrown', async () => {
           // Arrange
           const apiError = new OpenAI.APIError(
             400,
@@ -147,7 +147,7 @@ export const testProvider = ({
           }
         });
 
-        it('should throw AgentRuntimeError with NoOpenAIAPIKey if no apiKey is provided', async () => {
+        it('should throw AgentRuntimeError with InvalidProviderAPIKey if no apiKey is provided', async () => {
           try {
             new Runtime({});
           } catch (e) {
@@ -155,7 +155,7 @@ export const testProvider = ({
           }
         });
 
-        it('should return OpenAIBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
+        it('should return ProviderBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
           // Arrange
           const errorInfo = {
             cause: {
@@ -187,7 +187,7 @@ export const testProvider = ({
           }
         });
 
-        it('should return OpenAIBizError with an cause response with desensitize Url', async () => {
+        it('should return ProviderBizError with an cause response with desensitize Url', async () => {
           // Arrange
           const errorInfo = {
             cause: { message: 'api is undefined' },
@@ -223,7 +223,7 @@ export const testProvider = ({
           }
         });
 
-        it('should throw an InvalidHunyuanAPIKey error type on 401 status code', async () => {
+        it(`should throw an InvalidAPIKey error type on 401 status code`, async () => {
           // Mock the API call to simulate a 401 error
           const error = new Error('Unauthorized') as any;
           error.status = 401;
@@ -239,7 +239,7 @@ export const testProvider = ({
             // Expect the chat method to throw an error with InvalidHunyuanAPIKey
             expect(e).toEqual({
               endpoint: defaultBaseURL,
-              error: new Error('Unauthorized'),
+              error: error,
               errorType: invalidErrorType,
               provider,
             });

package/src/libs/agent-runtime/qwen/index.test.ts

@@ -1,251 +1,19 @@
 // @vitest-environment node
-import OpenAI from 'openai';
-import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
 import { ModelProvider } from '@/libs/agent-runtime';
-import { AgentRuntimeErrorType } from '@/libs/agent-runtime';
+import { testProvider } from '@/libs/agent-runtime/providerTestUtils';
 
-import * as debugStreamModule from '../utils/debugStream';
 import { LobeQwenAI } from './index';
 
 const provider = ModelProvider.Qwen;
 const defaultBaseURL = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
-const bizErrorType = AgentRuntimeErrorType.ProviderBizError;
-const invalidErrorType = AgentRuntimeErrorType.InvalidProviderAPIKey;
-
-// Mock the console.error to avoid polluting test output
-vi.spyOn(console, 'error').mockImplementation(() => {});
-
-let instance: LobeOpenAICompatibleRuntime;
-
-beforeEach(() => {
-  instance = new LobeQwenAI({ apiKey: 'test' });
-
-  // 使用 vi.spyOn 来模拟 chat.completions.create 方法
-  vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
-    new ReadableStream() as any,
-  );
-});
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('LobeQwenAI', () => {
-  describe('init', () => {
-    it('should correctly initialize with an API key', async () => {
-      const instance = new LobeQwenAI({ apiKey: 'test_api_key' });
-      expect(instance).toBeInstanceOf(LobeQwenAI);
-      expect(instance.baseURL).toEqual(defaultBaseURL);
-    });
-  });
-
-  describe('chat', () => {
-    describe('Error', () => {
-      it('should return QwenBizError with an openai error response when OpenAI.APIError is thrown', async () => {
-        // Arrange
-        const apiError = new OpenAI.APIError(
-          400,
-          {
-            status: 400,
-            error: {
-              message: 'Bad Request',
-            },
-          },
-          'Error message',
-          {},
-        );
-
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
-
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo-latest',
-            temperature: 0.999,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: {
-              error: { message: 'Bad Request' },
-              status: 400,
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should throw AgentRuntimeError with InvalidQwenAPIKey if no apiKey is provided', async () => {
-        try {
-          new LobeQwenAI({});
-        } catch (e) {
-          expect(e).toEqual({ errorType: invalidErrorType });
-        }
-      });
-
-      it('should return QwenBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
-        // Arrange
-        const errorInfo = {
-          stack: 'abc',
-          cause: {
-            message: 'api is undefined',
-          },
-        };
-        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
-
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
-
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo-latest',
-            temperature: 0.999,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: {
-              cause: { message: 'api is undefined' },
-              stack: 'abc',
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should return QwenBizError with an cause response with desensitize Url', async () => {
-        // Arrange
-        const errorInfo = {
-          stack: 'abc',
-          cause: { message: 'api is undefined' },
-        };
-        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
-
-        instance = new LobeQwenAI({
-          apiKey: 'test',
-
-          baseURL: 'https://api.abc.com/v1',
-        });
-
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
-
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo-latest',
-            temperature: 0.999,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: 'https://api.***.com/v1',
-            error: {
-              cause: { message: 'api is undefined' },
-              stack: 'abc',
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should throw an InvalidQwenAPIKey error type on 401 status code', async () => {
-        // Mock the API call to simulate a 401 error
-        const error = new Error('InvalidApiKey') as any;
-        error.status = 401;
-        vi.mocked(instance['client'].chat.completions.create).mockRejectedValue(error);
-
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo-latest',
-            temperature: 0.999,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: new Error('InvalidApiKey'),
-            errorType: invalidErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should return AgentRuntimeError for non-OpenAI errors', async () => {
-        // Arrange
-        const genericError = new Error('Generic Error');
-
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(genericError);
-
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo-latest',
-            temperature: 0.999,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            errorType: 'AgentRuntimeError',
-            provider,
-            error: {
-              name: genericError.name,
-              cause: genericError.cause,
-              message: genericError.message,
-              stack: genericError.stack,
-            },
-          });
-        }
-      });
-    });
-
-    describe('DEBUG', () => {
-      it('should call debugStream and return StreamingTextResponse when DEBUG_QWEN_CHAT_COMPLETION is 1', async () => {
-        // Arrange
-        const mockProdStream = new ReadableStream() as any; // 模拟的 prod 流
-        const mockDebugStream = new ReadableStream({
-          start(controller) {
-            controller.enqueue('Debug stream content');
-            controller.close();
-          },
-        }) as any;
-        mockDebugStream.toReadableStream = () => mockDebugStream; // 添加 toReadableStream 方法
-
-        // 模拟 chat.completions.create 返回值，包括模拟的 tee 方法
-        (instance['client'].chat.completions.create as Mock).mockResolvedValue({
-          tee: () => [mockProdStream, { toReadableStream: () => mockDebugStream }],
-        });
-
-        // 保存原始环境变量值
-        const originalDebugValue = process.env.DEBUG_QWEN_CHAT_COMPLETION;
-
-        // 模拟环境变量
-        process.env.DEBUG_QWEN_CHAT_COMPLETION = '1';
-        vi.spyOn(debugStreamModule, 'debugStream').mockImplementation(() => Promise.resolve());
-
-        // 执行测试
-        // 运行你的测试函数，确保它会在条件满足时调用 debugStream
-        // 假设的测试函数调用，你可能需要根据实际情况调整
-        await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'qwen-turbo-latest',
-          stream: true,
-          temperature: 0.999,
-        });
-
-        // 验证 debugStream 被调用
-        expect(debugStreamModule.debugStream).toHaveBeenCalled();
 
-        // 恢复原始环境变量值
-        process.env.DEBUG_QWEN_CHAT_COMPLETION = originalDebugValue;
-      });
-    });
-  });
+testProvider({
+  Runtime: LobeQwenAI,
+  provider,
+  defaultBaseURL,
+  chatDebugEnv: 'DEBUG_QWEN_CHAT_COMPLETION',
+  chatModel: 'qwen-2.5',
+  test: {
+    skipAPICall: true,
+  },
 });

package/src/libs/agent-runtime/runtimeMap.ts

@@ -16,6 +16,7 @@ import { LobeGroq } from './groq';
 import { LobeHigressAI } from './higress';
 import { LobeHuggingFaceAI } from './huggingface';
 import { LobeHunyuanAI } from './hunyuan';
+import { LobeInfiniAI } from './infiniai';
 import { LobeInternLMAI } from './internlm';
 import { LobeJinaAI } from './jina';
 import { LobeLMStudioAI } from './lmstudio';
@@ -31,6 +32,7 @@ import { LobePerplexityAI } from './perplexity';
 import { LobePPIOAI } from './ppio';
 import { LobeQwenAI } from './qwen';
 import { LobeSambaNovaAI } from './sambanova';
+import { LobeSearch1API } from './search1api';
 import { LobeSenseNovaAI } from './sensenova';
 import { LobeSiliconCloudAI } from './siliconcloud';
 import { LobeSparkAI } from './spark';
@@ -66,6 +68,7 @@ export const providerRuntimeMap = {
   higress: LobeHigressAI,
   huggingface: LobeHuggingFaceAI,
   hunyuan: LobeHunyuanAI,
+  infiniai: LobeInfiniAI,
   internlm: LobeInternLMAI,
   jina: LobeJinaAI,
   lmstudio: LobeLMStudioAI,
@@ -81,6 +84,7 @@ export const providerRuntimeMap = {
   ppio: LobePPIOAI,
   qwen: LobeQwenAI,
   sambanova: LobeSambaNovaAI,
+  search1api: LobeSearch1API,
   sensenova: LobeSenseNovaAI,
   siliconcloud: LobeSiliconCloudAI,
   spark: LobeSparkAI,

package/src/libs/agent-runtime/search1api/index.ts

@@ -0,0 +1,64 @@
+import OpenAI from 'openai';
+
+import type { ChatModelCard } from '@/types/llm';
+
+import { ChatStreamPayload, ModelProvider } from '../types';
+import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
+
+export interface Search1APIModelCard {
+  id: string;
+}
+
+export const LobeSearch1API = LobeOpenAICompatibleFactory({
+  baseURL: 'https://api.search1api.com/v1',
+  chatCompletion: {
+    handlePayload: (payload: ChatStreamPayload) => {
+      const { presence_penalty, frequency_penalty, stream = true, temperature, ...res } = payload;
+
+      let param;
+
+      if (presence_penalty !== 0) {
+        param = { presence_penalty };
+      } else {
+        const defaultFrequencyPenalty = 1;
+
+        param = { frequency_penalty: frequency_penalty || defaultFrequencyPenalty };
+      }
+
+      return {
+        ...res,
+        ...param,
+        stream,
+        temperature: temperature >= 2 ? undefined : temperature,
+      } as OpenAI.ChatCompletionCreateParamsStreaming;
+    },
+  },
+  debug: {
+    chatCompletion: () => process.env.DEBUG_SEARCH1API_CHAT_COMPLETION === '1',
+  },
+  models: async ({ client }) => {
+    const { LOBE_DEFAULT_MODEL_LIST } = await import('@/config/aiModels');
+
+    const modelsPage = (await client.models.list()) as any;
+    const modelList: Search1APIModelCard[] = modelsPage.data;
+
+    return modelList
+      .map((model) => {
+        const knownModel = LOBE_DEFAULT_MODEL_LIST.find(
+          (m) => model.id.toLowerCase() === m.id.toLowerCase(),
+        );
+
+        return {
+          contextWindowTokens: knownModel?.contextWindowTokens ?? undefined,
+          displayName: knownModel?.displayName ?? undefined,
+          enabled: knownModel?.enabled || false,
+          functionCall: knownModel?.abilities?.functionCall || false,
+          id: model.id,
+          reasoning: knownModel?.abilities?.reasoning || false,
+          vision: knownModel?.abilities?.vision || false,
+        };
+      })
+      .filter(Boolean) as ChatModelCard[];
+  },
+  provider: ModelProvider.Search1API,
+});