@lobehub/chat 0.162.16 → 0.162.18

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

@@ -0,0 +1,251 @@
+// @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 * 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',
+            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',
+            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',
+            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',
+            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',
+            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',
+          stream: true,
+          temperature: 0.999,
+        });
+
+        // 验证 debugStream 被调用
+        expect(debugStreamModule.debugStream).toHaveBeenCalled();
+
+        // 恢复原始环境变量值
+        process.env.DEBUG_QWEN_CHAT_COMPLETION = originalDebugValue;
+      });
+    });
+  });
+});

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

@@ -0,0 +1,28 @@
+import OpenAI from 'openai';
+
+import { ModelProvider } from '../types';
+import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
+
+export const LobeQwenAI = LobeOpenAICompatibleFactory({
+  baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+  chatCompletion: {
+    handlePayload: (payload) => {
+      const top_p = payload.top_p;
+      return {
+        ...payload,
+        stream: payload.stream ?? true,
+        top_p: top_p && top_p >= 1 ? 0.9999 : top_p,
+      } as OpenAI.ChatCompletionCreateParamsStreaming;
+    },
+  },
+  constructorOptions: {
+    defaultHeaders: {
+      'Content-Type': 'application/json',
+    },
+  },
+  debug: {
+    chatCompletion: () => process.env.DEBUG_QWEN_CHAT_COMPLETION === '1',
+  },
+
+  provider: ModelProvider.Qwen,
+});

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

@@ -10,8 +10,9 @@ import { LobeTogetherAI } from './index';
 
 const provider = 'togetherai';
 const defaultBaseURL = 'https://api.together.xyz/v1';
-const bizErrorType = 'TogetherAIBizError';
-const invalidErrorType = 'InvalidTogetherAIAPIKey';
+
+const bizErrorType = 'ProviderBizError';
+const invalidErrorType = 'InvalidProviderAPIKey';
 
 // Mock the console.error to avoid polluting test output
 vi.spyOn(console, 'error').mockImplementation(() => {});

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

@@ -1,6 +1,5 @@
 import { LOBE_DEFAULT_MODEL_LIST } from '@/config/modelProviders';
 
-import { AgentRuntimeErrorType } from '../error';
 import { ModelProvider } from '../types';
 import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
 import { TogetherAIModel } from './type';
@@ -17,10 +16,6 @@ export const LobeTogetherAI = LobeOpenAICompatibleFactory({
   debug: {
     chatCompletion: () => process.env.DEBUG_TOGETHERAI_CHAT_COMPLETION === '1',
   },
-  errorType: {
-    bizError: AgentRuntimeErrorType.TogetherAIBizError,
-    invalidAPIKey: AgentRuntimeErrorType.InvalidTogetherAIAPIKey,
-  },
   models: async ({ apiKey }) => {
     const data = await fetch(`${baseURL}/api/models`, {
       headers: {

package/src/libs/agent-runtime/types/type.ts

@@ -35,8 +35,8 @@ export enum ModelProvider {
   OpenAI = 'openai',
   OpenRouter = 'openrouter',
   Perplexity = 'perplexity',
+  Qwen = 'qwen',
   TogetherAI = 'togetherai',
-  // Tongyi = 'tongyi',
   ZeroOne = 'zeroone',
   ZhiPu = 'zhipu',
 }

package/src/libs/agent-runtime/utils/openaiCompatibleFactory/index.test.ts

@@ -14,8 +14,8 @@ import { LobeOpenAICompatibleFactory } from './index';
 
 const provider = 'groq';
 const defaultBaseURL = 'https://api.groq.com/openai/v1';
-const bizErrorType = 'GroqBizError';
-const invalidErrorType = 'InvalidGroqAPIKey';
+const bizErrorType = 'ProviderBizError';
+const invalidErrorType = 'InvalidProviderAPIKey';
 
 // Mock the console.error to avoid polluting test output
 vi.spyOn(console, 'error').mockImplementation(() => {});
@@ -34,10 +34,6 @@ const LobeMockProvider = LobeOpenAICompatibleFactory({
   debug: {
     chatCompletion: () => process.env.DEBUG_MOCKPROVIDER_CHAT_COMPLETION === '1',
   },
-  errorType: {
-    bizError: AgentRuntimeErrorType.GroqBizError,
-    invalidAPIKey: AgentRuntimeErrorType.InvalidGroqAPIKey,
-  },
   provider: ModelProvider.Groq,
 });
 
@@ -148,6 +144,127 @@ describe('LobeOpenAICompatibleFactory', () => {
         expect((await reader.read()).done).toBe(true);
       });
 
+      // https://github.com/lobehub/lobe-chat/issues/2752
+      it('should handle burn hair data chunks correctly', async () => {
+        const chunks = [
+          {
+            choices: [],
+            created: 0,
+            id: '',
+            model: '',
+            object: '',
+            prompt_filter_results: [
+              {
+                prompt_index: 0,
+                content_filter_results: {
+                  hate: { filtered: false, severity: 'safe' },
+                  self_harm: { filtered: false, severity: 'safe' },
+                  sexual: { filtered: false, severity: 'safe' },
+                  violence: { filtered: false, severity: 'safe' },
+                },
+              },
+            ],
+          },
+          {
+            choices: [
+              {
+                delta: { content: '', role: 'assistant' },
+                finish_reason: null,
+                index: 0,
+                logprobs: null,
+              },
+            ],
+            created: 1717249403,
+            id: 'chatcmpl-9VJIxA3qNM2C2YdAnNYA2KgDYfFnX',
+            model: 'gpt-4o-2024-05-13',
+            object: 'chat.completion.chunk',
+            system_fingerprint: 'fp_5f4bad809a',
+          },
+          {
+            choices: [{ delta: { content: '1' }, finish_reason: null, index: 0, logprobs: null }],
+            created: 1717249403,
+            id: 'chatcmpl-9VJIxA3qNM2C2YdAnNYA2KgDYfFnX',
+            model: 'gpt-4o-2024-05-13',
+            object: 'chat.completion.chunk',
+            system_fingerprint: 'fp_5f4bad809a',
+          },
+          {
+            choices: [{ delta: {}, finish_reason: 'stop', index: 0, logprobs: null }],
+            created: 1717249403,
+            id: 'chatcmpl-9VJIxA3qNM2C2YdAnNYA2KgDYfFnX',
+            model: 'gpt-4o-2024-05-13',
+            object: 'chat.completion.chunk',
+            system_fingerprint: 'fp_5f4bad809a',
+          },
+          {
+            choices: [
+              {
+                content_filter_offsets: { check_offset: 35, start_offset: 35, end_offset: 36 },
+                content_filter_results: {
+                  hate: { filtered: false, severity: 'safe' },
+                  self_harm: { filtered: false, severity: 'safe' },
+                  sexual: { filtered: false, severity: 'safe' },
+                  violence: { filtered: false, severity: 'safe' },
+                },
+                finish_reason: null,
+                index: 0,
+              },
+            ],
+            created: 0,
+            id: '',
+            model: '',
+            object: '',
+          },
+        ];
+        const mockStream = new ReadableStream({
+          start(controller) {
+            chunks.forEach((item) => {
+              controller.enqueue(item);
+            });
+
+            controller.close();
+          },
+        });
+        vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+          mockStream as any,
+        );
+
+        const stream: string[] = [];
+        const result = await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'gpt-3.5-turbo',
+          temperature: 0,
+        });
+        const decoder = new TextDecoder();
+        const reader = result.body!.getReader();
+
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          stream.push(decoder.decode(value));
+        }
+
+        expect(stream).toEqual(
+          [
+            'id: ',
+            'event: data',
+            'data: {"choices":[],"created":0,"id":"","model":"","object":"","prompt_filter_results":[{"prompt_index":0,"content_filter_results":{"hate":{"filtered":false,"severity":"safe"},"self_harm":{"filtered":false,"severity":"safe"},"sexual":{"filtered":false,"severity":"safe"},"violence":{"filtered":false,"severity":"safe"}}}]}\n',
+            'id: chatcmpl-9VJIxA3qNM2C2YdAnNYA2KgDYfFnX',
+            'event: text',
+            'data: ""\n',
+            'id: chatcmpl-9VJIxA3qNM2C2YdAnNYA2KgDYfFnX',
+            'event: text',
+            'data: "1"\n',
+            'id: chatcmpl-9VJIxA3qNM2C2YdAnNYA2KgDYfFnX',
+            'event: stop',
+            'data: "stop"\n',
+            'id: ',
+            'event: data',
+            'data: {"id":"","index":0}\n',
+          ].map((item) => `${item}\n`),
+        );
+      });
+
       it('should transform non-streaming response to stream correctly', async () => {
         const mockResponse: OpenAI.ChatCompletion = {
           id: 'a',

package/src/libs/agent-runtime/utils/openaiCompatibleFactory/index.ts

@@ -5,7 +5,7 @@ import { TextToImagePayload } from '@/libs/agent-runtime/types/textToImage';
 import { ChatModelCard } from '@/types/llm';
 
 import { LobeRuntimeAI } from '../../BaseAI';
-import { ILobeAgentRuntimeErrorType } from '../../error';
+import { AgentRuntimeErrorType, ILobeAgentRuntimeErrorType } from '../../error';
 import { ChatCompetitionOptions, ChatCompletionErrorPayload, ChatStreamPayload } from '../../types';
 import { AgentRuntimeError } from '../createError';
 import { debugStream } from '../debugStream';
@@ -37,7 +37,7 @@ interface OpenAICompatibleFactoryOptions {
   debug?: {
     chatCompletion: () => boolean;
   };
-  errorType: {
+  errorType?: {
     bizError: ILobeAgentRuntimeErrorType;
     invalidAPIKey: ILobeAgentRuntimeErrorType;
   };
@@ -52,19 +52,24 @@ interface OpenAICompatibleFactoryOptions {
 export const LobeOpenAICompatibleFactory = ({
   provider,
   baseURL: DEFAULT_BASE_URL,
-  errorType: ErrorType,
+  errorType,
   debug,
   constructorOptions,
   chatCompletion,
   models,
-}: OpenAICompatibleFactoryOptions) =>
-  class LobeOpenAICompatibleAI implements LobeRuntimeAI {
+}: OpenAICompatibleFactoryOptions) => {
+  const ErrorType = {
+    bizError: errorType?.bizError || AgentRuntimeErrorType.ProviderBizError,
+    invalidAPIKey: errorType?.invalidAPIKey || AgentRuntimeErrorType.InvalidProviderAPIKey,
+  };
+
+  return class LobeOpenAICompatibleAI implements LobeRuntimeAI {
     client: OpenAI;
 
     baseURL: string;
 
     constructor({ apiKey, baseURL = DEFAULT_BASE_URL, ...res }: ClientOptions) {
-      if (!apiKey) throw AgentRuntimeError.createError(ErrorType.invalidAPIKey);
+      if (!apiKey) throw AgentRuntimeError.createError(ErrorType?.invalidAPIKey);
 
       this.client = new OpenAI({ apiKey, baseURL, ...constructorOptions, ...res });
       this.baseURL = this.client.baseURL;
@@ -286,3 +291,4 @@ export const LobeOpenAICompatibleFactory = ({
       });
     }
   };
+};

package/src/libs/agent-runtime/utils/streams/openai.ts

@@ -52,7 +52,7 @@ export const transformOpenAIStream = (chunk: OpenAI.ChatCompletionChunk): Stream
     return { data: item.finish_reason, id: chunk.id, type: 'stop' };
   }
 
-  if (item.delta.content === null) {
+  if (item.delta?.content === null) {
     return { data: item.delta, id: chunk.id, type: 'data' };
   }
 

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

@@ -9,8 +9,9 @@ import { LobeZeroOneAI } from './index';
 
 const provider = 'zeroone';
 const defaultBaseURL = 'https://api.lingyiwanwu.com/v1';
-const bizErrorType = 'ZeroOneBizError';
-const invalidErrorType = 'InvalidZeroOneAPIKey';
+
+const bizErrorType = 'ProviderBizError';
+const invalidErrorType = 'InvalidProviderAPIKey';
 
 // Mock the console.error to avoid polluting test output
 vi.spyOn(console, 'error').mockImplementation(() => {});

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

@@ -1,4 +1,3 @@
-import { AgentRuntimeErrorType } from '../error';
 import { ModelProvider } from '../types';
 import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
 
@@ -7,9 +6,6 @@ export const LobeZeroOneAI = LobeOpenAICompatibleFactory({
   debug: {
     chatCompletion: () => process.env.DEBUG_ZEROONE_CHAT_COMPLETION === '1',
   },
-  errorType: {
-    bizError: AgentRuntimeErrorType.ZeroOneBizError,
-    invalidAPIKey: AgentRuntimeErrorType.InvalidZeroOneAPIKey,
-  },
+
   provider: ModelProvider.ZeroOne,
 });

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

@@ -8,6 +8,9 @@ import * as debugStreamModule from '@/libs/agent-runtime/utils/debugStream';
 import * as authTokenModule from './authToken';
 import { LobeZhipuAI } from './index';
 
+const bizErrorType = 'ProviderBizError';
+const invalidErrorType = 'InvalidProviderAPIKey';
+
 // Mock相关依赖
 vi.mock('./authToken');
 
@@ -33,7 +36,7 @@ describe('LobeZhipuAI', () => {
       try {
         await LobeZhipuAI.fromAPIKey({ apiKey: 'asd' });
       } catch (e) {
-        expect(e).toEqual({ errorType: 'InvalidZhipuAPIKey' });
+        expect(e).toEqual({ errorType: invalidErrorType });
       }
     });
   });
@@ -164,7 +167,7 @@ describe('LobeZhipuAI', () => {
               error: { message: 'Bad Request' },
               status: 400,
             },
-            errorType: 'ZhipuBizError',
+            errorType: bizErrorType,
             provider: 'zhipu',
           });
         }
@@ -174,7 +177,7 @@ describe('LobeZhipuAI', () => {
         try {
           await LobeZhipuAI.fromAPIKey({ apiKey: '' });
         } catch (e) {
-          expect(e).toEqual({ errorType: 'InvalidZhipuAPIKey' });
+          expect(e).toEqual({ errorType: invalidErrorType });
         }
       });
 
@@ -204,7 +207,7 @@ describe('LobeZhipuAI', () => {
               cause: { message: 'api is undefined' },
               stack: 'abc',
             },
-            errorType: 'ZhipuBizError',
+            errorType: bizErrorType,
             provider: 'zhipu',
           });
         }
@@ -240,7 +243,7 @@ describe('LobeZhipuAI', () => {
               cause: { message: 'api is undefined' },
               stack: 'abc',
             },
-            errorType: 'ZhipuBizError',
+            errorType: bizErrorType,
             provider: 'zhipu',
           });
         }

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

@@ -31,7 +31,7 @@ export class LobeZhipuAI implements LobeRuntimeAI {
 
   static async fromAPIKey({ apiKey, baseURL = DEFAULT_BASE_URL, ...res }: ClientOptions) {
     const invalidZhipuAPIKey = AgentRuntimeError.createError(
-      AgentRuntimeErrorType.InvalidZhipuAPIKey,
+      AgentRuntimeErrorType.InvalidProviderAPIKey,
     );
 
     if (!apiKey) throw invalidZhipuAPIKey;
@@ -70,7 +70,7 @@ export class LobeZhipuAI implements LobeRuntimeAI {
     } catch (error) {
       const { errorResult, RuntimeError } = handleOpenAIError(error);
 
-      const errorType = RuntimeError || AgentRuntimeErrorType.ZhipuBizError;
+      const errorType = RuntimeError || AgentRuntimeErrorType.ProviderBizError;
       let desensitizedEndpoint = this.baseURL;
 
       if (this.baseURL !== DEFAULT_BASE_URL) {