@lobehub/chat 1.68.9 → 1.68.10

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

@@ -1,19 +1,22 @@
 // @vitest-environment node
-import OpenAI from 'openai';
-import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Mock, afterEach, beforeEach, expect, it, vi } from 'vitest';
 
-import { ChatStreamCallbacks, LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
+import { LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
+import { testProvider } from '@/libs/agent-runtime/providerTestUtils';
 
-import * as debugStreamModule from '../utils/debugStream';
 import { LobeMistralAI } from './index';
 
-const provider = 'mistral';
-const defaultBaseURL = 'https://api.mistral.ai/v1';
-const bizErrorType = 'ProviderBizError';
-const invalidErrorType = 'InvalidProviderAPIKey';
+testProvider({
+  provider: 'mistral',
+  defaultBaseURL: 'https://api.mistral.ai/v1',
+  chatModel: 'open-mistral-7b',
+  Runtime: LobeMistralAI,
+  chatDebugEnv: 'DEBUG_MISTRAL_CHAT_COMPLETION',
 
-// Mock the console.error to avoid polluting test output
-vi.spyOn(console, 'error').mockImplementation(() => {});
+  test: {
+    skipAPICall: true,
+  },
+});
 
 let instance: LobeOpenAICompatibleRuntime;
 
@@ -30,302 +33,38 @@ afterEach(() => {
   vi.clearAllMocks();
 });
 
-describe('LobeMistralAI', () => {
-  describe('init', () => {
-    it('should correctly initialize with an API key', async () => {
-      const instance = new LobeMistralAI({ apiKey: 'test_api_key' });
-      expect(instance).toBeInstanceOf(LobeMistralAI);
-      expect(instance.baseURL).toEqual(defaultBaseURL);
+describe('specific LobeMistralAI tests', () => {
+  it(`should call API with corresponding options`, async () => {
+    // Arrange
+    const mockStream = new ReadableStream();
+    const mockResponse = Promise.resolve(mockStream);
+
+    (instance['client'].chat.completions.create as Mock).mockResolvedValue(mockResponse);
+
+    // Act
+    const result = await instance.chat({
+      max_tokens: 1024,
+      messages: [{ content: 'Hello', role: 'user' }],
+      model: 'open-mistral-7b',
+      temperature: 0.7,
+      top_p: 1,
     });
-  });
-
-  describe('chat', () => {
-    it('should return a StreamingTextResponse on successful API call', async () => {
-      // Arrange
-      const mockStream = new ReadableStream();
-      const mockResponse = Promise.resolve(mockStream);
-
-      (instance['client'].chat.completions.create as Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await instance.chat({
-        messages: [{ content: 'Hello', role: 'user' }],
-        model: 'open-mistral-7b',
-        temperature: 0,
-      });
 
-      // Assert
-      expect(result).toBeInstanceOf(Response);
-    });
-
-    it('should call Mistral API with supported options in streaming mode', async () => {
-      // Arrange
-      const mockStream = new ReadableStream();
-      const mockResponse = Promise.resolve(mockStream);
-
-      (instance['client'].chat.completions.create as Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await instance.chat({
+    // Assert
+    expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+      {
         max_tokens: 1024,
         messages: [{ content: 'Hello', role: 'user' }],
         model: 'open-mistral-7b',
-        temperature: 0.7,
-        top_p: 1,
-      });
-
-      // Assert
-      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-        {
-          max_tokens: 1024,
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'open-mistral-7b',
-          stream: true,
-          temperature: 0.35,
-          top_p: 1,
+        stream: true,
+        stream_options: {
+          include_usage: true,
         },
-        { headers: { Accept: '*/*' } },
-      );
-      expect(result).toBeInstanceOf(Response);
-    });
-
-    it('should call Mistral API without unsupported options', async () => {
-      // Arrange
-      const mockStream = new ReadableStream();
-      const mockResponse = Promise.resolve(mockStream);
-
-      (instance['client'].chat.completions.create as Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await instance.chat({
-        frequency_penalty: 0.5, // unsupported option
-        max_tokens: 1024,
-        messages: [{ content: 'Hello', role: 'user' }],
-        model: 'open-mistral-7b',
-        presence_penalty: 0.5, // unsupported option
-        temperature: 0.7,
+        temperature: 0.35,
         top_p: 1,
-      });
-
-      // Assert
-      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-        {
-          max_tokens: 1024,
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'open-mistral-7b',
-          stream: true,
-          temperature: 0.35,
-          top_p: 1,
-        },
-        { headers: { Accept: '*/*' } },
-      );
-      expect(result).toBeInstanceOf(Response);
-    });
-
-    describe('Error', () => {
-      it('should return MistralBizError 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: 'open-mistral-7b',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: {
-              error: { message: 'Bad Request' },
-              status: 400,
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should throw AgentRuntimeError with InvalidMistralAPIKey if no apiKey is provided', async () => {
-        try {
-          new LobeMistralAI({});
-        } catch (e) {
-          expect(e).toEqual({ errorType: invalidErrorType });
-        }
-      });
-
-      it('should return MistralBizError 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: 'open-mistral-7b',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: {
-              cause: { message: 'api is undefined' },
-              stack: 'abc',
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should return MistralBizError 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 LobeMistralAI({
-          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: 'open-mistral-7b',
-            temperature: 0,
-          });
-        } 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 InvalidMistralAPIKey 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;
-        vi.mocked(instance['client'].chat.completions.create).mockRejectedValue(error);
-
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'gpt-3.5-turbo',
-            temperature: 0,
-          });
-        } catch (e) {
-          // Expect the chat method to throw an error with InvalidMoonshotAPIKey
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: new Error('Unauthorized'),
-            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: 'open-mistral-7b',
-            temperature: 0,
-          });
-        } 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_MISTRAL_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_MISTRAL_CHAT_COMPLETION;
-
-        // 模拟环境变量
-        process.env.DEBUG_MISTRAL_CHAT_COMPLETION = '1';
-        vi.spyOn(debugStreamModule, 'debugStream').mockImplementation(() => Promise.resolve());
-
-        // 执行测试
-        // 运行你的测试函数，确保它会在条件满足时调用 debugStream
-        // 假设的测试函数调用，你可能需要根据实际情况调整
-        await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'open-mistral-7b',
-          temperature: 0,
-        });
-
-        // 验证 debugStream 被调用
-        expect(debugStreamModule.debugStream).toHaveBeenCalled();
-
-        // 恢复原始环境变量值
-        process.env.DEBUG_MISTRAL_CHAT_COMPLETION = originalDebugValue;
-      });
-    });
+      },
+      { headers: { Accept: '*/*' } },
+    );
+    expect(result).toBeInstanceOf(Response);
   });
 });

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

@@ -163,13 +163,13 @@ describe('LobePerplexityAI', () => {
         },
         {
           id: '506d64fb-e7f2-4d94-b80f-158369e9446d',
-          model: 'sonar-pro',
-          created: 1739896615,
+          model: 'sonar-reasoning-pro',
+          created: 1741250924,
           usage: {
-            prompt_tokens: 4,
-            completion_tokens: 14,
-            total_tokens: 18,
-            citation_tokens: 2217,
+            prompt_tokens: 2,
+            completion_tokens: 685,
+            total_tokens: 687,
+            citation_tokens: 3058,
             num_search_queries: 1,
           },
           citations: [
@@ -185,11 +185,13 @@ describe('LobePerplexityAI', () => {
           choices: [
             {
               index: 0,
-              finish_reason: null,
+              finish_reason: 'stop',
               message: {
                 role: 'assistant',
-                content: '杭州今天和未来几天的天气预报如',
+                content:
+                  '<think>\n好的，我现在要处理用户的我需要确定这个查询的类型。用户显然是在询问当前的天气情况和预报，因此属于天气预报类型。接下来我要查看提供的搜索结果，看看这些来源是否能提供准确的信息。\n\n第一个来源是weather.com.cn的、西北风5~6级等。接着查看第二个结果[2]是中央气象台的详细分时数据，比如7月18日和21日的温度、降水、风速等信息。[3]来自中国气象局的气象预报显示有阴天和多云交替的情况，（如星期三03/05阴温暖但空气质量差。[6][7]则是杭州市气象台的最新天气预报发布情况：后半夜转多云明天白天继续多云的天气。\n\n现在要将这些信息整合起来形成连贯的回答。需要注意是否有矛盾的地方以及按照可信度部或东北部常见四至五级阵风；昼夜温差较大比如最高温可达20多摄氏度最低至10℃左右这样需要提醒注意衣物调整防寒保暖同时也指出空气质量在某些时段可能不佳特别是根据[5]，AccuWeather提示空气质响出行健康的重点要素如空气指标并且保证引用每个相关数据都注明正确的出处编号避免遗漏重要细节同时保持回答简洁明了使用户一目了然.\n</think>\n\n杭州近期以阴到多云天气为主，夜间偶有小雨[1 未来三日预报\n- **今天傍晚至夜间**：局部小雨渐止转阴到多云\\[6\\] [7]\n- **明日（周六）**  \n  - 白天多云为主   \n  - 温度区间16℃~22℃，西北风5~6级 \\[2\\] [3]\n- **后天（周日）**\n\\] [3]\n\n### *注意事项*\n1. **昼夜温差大**：早晚低温多在10°C以下需加外套防风保温；\n2. **空气污染警告** AccuWeather指出当地PM指数超标易引发达呼吸道不适建议尽量减少户外长时间活动时r/china/zjejiang/hangzhou" target="_blank">墨迹实况雷达图</a>获取临近降水动态.',
               },
+              delta: { role: 'assistant', content: '' },
             },
           ],
         },
@@ -238,8 +240,8 @@ describe('LobePerplexityAI', () => {
           'event: text',
           'data: "天和未来几天的"\n',
           'id: 506d64fb-e7f2-4d94-b80f-158369e9446d',
-          'event: data',
-          'data: {"id":"506d64fb-e7f2-4d94-b80f-158369e9446d","index":0}\n',
+          'event: usage',
+          'data: {"inputCitationTokens":3058,"inputTextTokens":2,"outputTextTokens":685,"totalInputTokens":3060,"totalOutputTokens":685,"totalTokens":3745}\n',
         ].map((line) => `${line}\n`),
       );
 

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

@@ -13,6 +13,9 @@ interface TesstProviderParams {
   defaultBaseURL: string;
   invalidErrorType?: string;
   provider: string;
+  test?: {
+    skipAPICall?: boolean;
+  };
 }
 
 export const testProvider = ({
@@ -23,6 +26,7 @@ export const testProvider = ({
   Runtime,
   chatDebugEnv,
   chatModel,
+  test = {},
 }: TesstProviderParams) => {
   // Mock the console.error to avoid polluting test output
   vi.spyOn(console, 'error').mockImplementation(() => {});
@@ -52,6 +56,60 @@ export const testProvider = ({
     });
 
     describe('chat', () => {
+      it('should return a StreamingTextResponse on successful API call', async () => {
+        // Arrange
+        const mockStream = new ReadableStream();
+        const mockResponse = Promise.resolve(mockStream);
+
+        (instance['client'].chat.completions.create as Mock).mockResolvedValue(mockResponse);
+
+        // Act
+        const result = await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: chatModel,
+          temperature: 0,
+        });
+
+        // Assert
+        expect(result).toBeInstanceOf(Response);
+      });
+
+      if (!test?.skipAPICall) {
+        it(`should call ${provider} API with corresponding options`, async () => {
+          // Arrange
+          const mockStream = new ReadableStream();
+          const mockResponse = Promise.resolve(mockStream);
+
+          (instance['client'].chat.completions.create as Mock).mockResolvedValue(mockResponse);
+
+          // Act
+          const result = await instance.chat({
+            max_tokens: 1024,
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: chatModel,
+            temperature: 0.7,
+            top_p: 1,
+          });
+
+          // Assert
+          expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+            {
+              max_tokens: 1024,
+              messages: [{ content: 'Hello', role: 'user' }],
+              model: chatModel,
+              stream: true,
+              stream_options: {
+                include_usage: true,
+              },
+              temperature: 0.7,
+              top_p: 1,
+            },
+            { headers: { Accept: '*/*' } },
+          );
+          expect(result).toBeInstanceOf(Response);
+        });
+      }
+
       describe('Error', () => {
         it('should return OpenAIBizError with an openai error response when OpenAI.APIError is thrown', async () => {
           // Arrange