@lobehub/chat 1.40.4 → 1.42.0

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

@@ -2,8 +2,9 @@
 import OpenAI from 'openai';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import Qwen from '@/config/modelProviders/qwen';
-import { AgentRuntimeErrorType, ModelProvider } from '@/libs/agent-runtime';
+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';
@@ -16,7 +17,7 @@ const invalidErrorType = AgentRuntimeErrorType.InvalidProviderAPIKey;
 // Mock the console.error to avoid polluting test output
 vi.spyOn(console, 'error').mockImplementation(() => {});
 
-let instance: LobeQwenAI;
+let instance: LobeOpenAICompatibleRuntime;
 
 beforeEach(() => {
   instance = new LobeQwenAI({ apiKey: 'test' });
@@ -40,183 +41,7 @@ describe('LobeQwenAI', () => {
     });
   });
 
-  describe('models', () => {
-    it('should correctly list available models', async () => {
-      const instance = new LobeQwenAI({ apiKey: 'test_api_key' });
-      vi.spyOn(instance, 'models').mockResolvedValue(Qwen.chatModels);
-
-      const models = await instance.models();
-      expect(models).toEqual(Qwen.chatModels);
-    });
-  });
-
   describe('chat', () => {
-    describe('Params', () => {
-      it('should call llms with proper options', async () => {
-        const mockStream = new ReadableStream();
-        const mockResponse = Promise.resolve(mockStream);
-
-        (instance['client'].chat.completions.create as Mock).mockResolvedValue(mockResponse);
-
-        const result = await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'qwen-turbo',
-          temperature: 0.6,
-          top_p: 0.7,
-        });
-
-        // Assert
-        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-          {
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo',
-            temperature: 0.6,
-            stream: true,
-            top_p: 0.7,
-            result_format: 'message',
-          },
-          { headers: { Accept: '*/*' } },
-        );
-        expect(result).toBeInstanceOf(Response);
-      });
-
-      it('should call vlms with proper options', async () => {
-        const mockStream = new ReadableStream();
-        const mockResponse = Promise.resolve(mockStream);
-
-        (instance['client'].chat.completions.create as Mock).mockResolvedValue(mockResponse);
-
-        const result = await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'qwen-vl-plus',
-          temperature: 0.6,
-          top_p: 0.7,
-        });
-
-        // Assert
-        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-          {
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-vl-plus',
-            stream: true,
-          },
-          { headers: { Accept: '*/*' } },
-        );
-        expect(result).toBeInstanceOf(Response);
-      });
-
-      it('should transform non-streaming response to stream correctly', async () => {
-        const mockResponse = {
-          id: 'chatcmpl-fc539f49-51a8-94be-8061',
-          object: 'chat.completion',
-          created: 1719901794,
-          model: 'qwen-turbo',
-          choices: [
-            {
-              index: 0,
-              message: { role: 'assistant', content: 'Hello' },
-              finish_reason: 'stop',
-              logprobs: null,
-            },
-          ],
-        } as OpenAI.ChatCompletion;
-        vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
-          mockResponse as any,
-        );
-
-        const result = await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'qwen-turbo',
-          temperature: 0.6,
-          stream: false,
-        });
-
-        const decoder = new TextDecoder();
-        const reader = result.body!.getReader();
-        const stream: string[] = [];
-
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          stream.push(decoder.decode(value));
-        }
-
-        expect(stream).toEqual([
-          'id: chatcmpl-fc539f49-51a8-94be-8061\n',
-          'event: text\n',
-          'data: "Hello"\n\n',
-          'id: chatcmpl-fc539f49-51a8-94be-8061\n',
-          'event: stop\n',
-          'data: "stop"\n\n',
-        ]);
-
-        expect((await reader.read()).done).toBe(true);
-      });
-
-      it('should set temperature to undefined if temperature is 0 or >= 2', async () => {
-        const temperatures = [0, 2, 3];
-        const expectedTemperature = undefined;
-
-        for (const temp of temperatures) {
-          vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
-            new ReadableStream() as any,
-          );
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo',
-            temperature: temp,
-          });
-          expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-            expect.objectContaining({
-              messages: expect.any(Array),
-              model: 'qwen-turbo',
-              temperature: expectedTemperature,
-            }),
-            expect.any(Object),
-          );
-        }
-      });
-
-      it('should set temperature to original temperature', async () => {
-        vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
-          new ReadableStream() as any,
-        );
-        await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'qwen-turbo',
-          temperature: 1.5,
-        });
-        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-          expect.objectContaining({
-            messages: expect.any(Array),
-            model: 'qwen-turbo',
-            temperature: 1.5,
-          }),
-          expect.any(Object),
-        );
-      });
-
-      it('should set temperature to Float', async () => {
-        const createMock = vi.fn().mockResolvedValue(new ReadableStream() as any);
-        vi.spyOn(instance['client'].chat.completions, 'create').mockImplementation(createMock);
-        await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'qwen-turbo',
-          temperature: 1,
-        });
-        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-          expect.objectContaining({
-            messages: expect.any(Array),
-            model: 'qwen-turbo',
-            temperature: expect.any(Number),
-          }),
-          expect.any(Object),
-        );
-        const callArgs = createMock.mock.calls[0][0];
-        expect(Number.isInteger(callArgs.temperature)).toBe(false); // Temperature is always not an integer
-      });
-    });
-
     describe('Error', () => {
       it('should return QwenBizError with an openai error response when OpenAI.APIError is thrown', async () => {
         // Arrange
@@ -238,7 +63,7 @@ describe('LobeQwenAI', () => {
         try {
           await instance.chat({
             messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo',
+            model: 'qwen-turbo-latest',
             temperature: 0.999,
           });
         } catch (e) {
@@ -278,7 +103,7 @@ describe('LobeQwenAI', () => {
         try {
           await instance.chat({
             messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo',
+            model: 'qwen-turbo-latest',
             temperature: 0.999,
           });
         } catch (e) {
@@ -304,7 +129,8 @@ describe('LobeQwenAI', () => {
 
         instance = new LobeQwenAI({
           apiKey: 'test',
-          baseURL: defaultBaseURL,
+
+          baseURL: 'https://api.abc.com/v1',
         });
 
         vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
@@ -313,13 +139,12 @@ describe('LobeQwenAI', () => {
         try {
           await instance.chat({
             messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo',
+            model: 'qwen-turbo-latest',
             temperature: 0.999,
           });
         } catch (e) {
           expect(e).toEqual({
-            /* Desensitizing is unnecessary for a public-accessible gateway endpoint. */
-            endpoint: defaultBaseURL,
+            endpoint: 'https://api.***.com/v1',
             error: {
               cause: { message: 'api is undefined' },
               stack: 'abc',
@@ -339,7 +164,7 @@ describe('LobeQwenAI', () => {
         try {
           await instance.chat({
             messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo',
+            model: 'qwen-turbo-latest',
             temperature: 0.999,
           });
         } catch (e) {
@@ -362,7 +187,7 @@ describe('LobeQwenAI', () => {
         try {
           await instance.chat({
             messages: [{ content: 'Hello', role: 'user' }],
-            model: 'qwen-turbo',
+            model: 'qwen-turbo-latest',
             temperature: 0.999,
           });
         } catch (e) {
@@ -410,7 +235,7 @@ describe('LobeQwenAI', () => {
         // 假设的测试函数调用，你可能需要根据实际情况调整
         await instance.chat({
           messages: [{ content: 'Hello', role: 'user' }],
-          model: 'qwen-turbo',
+          model: 'qwen-turbo-latest',
           stream: true,
           temperature: 0.999,
         });

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

@@ -1,129 +1,50 @@
-import { omit } from 'lodash-es';
-import OpenAI, { ClientOptions } from 'openai';
+import { ModelProvider } from '../types';
+import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
 
-import Qwen from '@/config/modelProviders/qwen';
-
-import { LobeRuntimeAI } from '../BaseAI';
-import { AgentRuntimeErrorType } from '../error';
-import { ChatCompetitionOptions, ChatStreamPayload, ModelProvider } from '../types';
-import { AgentRuntimeError } from '../utils/createError';
-import { debugStream } from '../utils/debugStream';
-import { handleOpenAIError } from '../utils/handleOpenAIError';
-import { transformResponseToStream } from '../utils/openaiCompatibleFactory';
-import { StreamingResponse } from '../utils/response';
 import { QwenAIStream } from '../utils/streams';
 
-const DEFAULT_BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
-
-/**
- * Use DashScope OpenAI compatible mode for now.
- * DashScope OpenAI [compatible mode](https://help.aliyun.com/zh/dashscope/developer-reference/tongyi-qianwen-vl-plus-api) currently supports base64 image input for vision models e.g. qwen-vl-plus.
- * You can use images input either:
- * 1. Use qwen-vl-* out of box with base64 image_url input;
- * or
- * 2. Set S3-* enviroment variables properly to store all uploaded files.
- */
-export class LobeQwenAI implements LobeRuntimeAI {
-  client: OpenAI;
-  baseURL: string;
-
-  constructor({
-    apiKey,
-    baseURL = DEFAULT_BASE_URL,
-    ...res
-  }: ClientOptions & Record<string, any> = {}) {
-    if (!apiKey) throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey);
-    this.client = new OpenAI({ apiKey, baseURL, ...res });
-    this.baseURL = this.client.baseURL;
-  }
-
-  async models() {
-    return Qwen.chatModels;
-  }
-
-  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
-    try {
-      const params = this.buildCompletionParamsByModel(payload);
-
-      const response = await this.client.chat.completions.create(
-        params as OpenAI.ChatCompletionCreateParamsStreaming & { result_format: string },
-        {
-          headers: { Accept: '*/*' },
-          signal: options?.signal,
-        },
-      );
-
-      if (params.stream) {
-        const [prod, debug] = response.tee();
-
-        if (process.env.DEBUG_QWEN_CHAT_COMPLETION === '1') {
-          debugStream(debug.toReadableStream()).catch(console.error);
-        }
-
-        return StreamingResponse(QwenAIStream(prod, options?.callback), {
-          headers: options?.headers,
-        });
-      }
-
-      const stream = transformResponseToStream(response as unknown as OpenAI.ChatCompletion);
-
-      return StreamingResponse(QwenAIStream(stream, options?.callback), {
-        headers: options?.headers,
-      });
-    } catch (error) {
-      if ('status' in (error as any)) {
-        switch ((error as Response).status) {
-          case 401: {
-            throw AgentRuntimeError.chat({
-              endpoint: this.baseURL,
-              error: error as any,
-              errorType: AgentRuntimeErrorType.InvalidProviderAPIKey,
-              provider: ModelProvider.Qwen,
-            });
-          }
-
-          default: {
-            break;
-          }
-        }
-      }
-      const { errorResult, RuntimeError } = handleOpenAIError(error);
-      const errorType = RuntimeError || AgentRuntimeErrorType.ProviderBizError;
-
-      throw AgentRuntimeError.chat({
-        endpoint: this.baseURL,
-        error: errorResult,
-        errorType,
-        provider: ModelProvider.Qwen,
-      });
-    }
-  }
-
-  private buildCompletionParamsByModel(payload: ChatStreamPayload) {
-    const { model, temperature, top_p, stream, messages, tools } = payload;
-    const isVisionModel = model.startsWith('qwen-vl');
-
-    const params = {
-      ...payload,
-      messages,
-      result_format: 'message',
-      stream: !!tools?.length ? false : (stream ?? true),
-      temperature:
-        temperature === 0 || temperature >= 2 ? undefined : temperature === 1 ? 0.999 : temperature, // 'temperature' must be Float
-      top_p: top_p && top_p >= 1 ? 0.999 : top_p,
-    };
-
-    /* Qwen-vl models temporarily do not support parameters below. */
-    /* Notice: `top_p` imposes significant impact on the result，the default 1 or 0.999 is not a proper choice. */
-    return isVisionModel
-      ? omit(
-          params,
-          'presence_penalty',
-          'frequency_penalty',
-          'temperature',
-          'result_format',
-          'top_p',
-        )
-      : omit(params, 'frequency_penalty');
-  }
-}
+/*
+  QwenLegacyModels: A set of legacy Qwen models that do not support presence_penalty.
+  Currently, presence_penalty is only supported on Qwen commercial models and open-source models starting from Qwen 1.5 and later.
+*/
+export const QwenLegacyModels = new Set([
+  'qwen-72b-chat',
+  'qwen-14b-chat',
+  'qwen-7b-chat',
+  'qwen-1.8b-chat',
+  'qwen-1.8b-longcontext-chat',
+]);
+
+export const LobeQwenAI = LobeOpenAICompatibleFactory({
+  baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+  chatCompletion: {
+    handlePayload: (payload) => {
+      const { model, presence_penalty, temperature, top_p, ...rest } = payload;
+
+      return {
+        ...rest,
+        frequency_penalty: undefined,
+        model,
+        presence_penalty:
+          QwenLegacyModels.has(model)
+            ? undefined
+            : (presence_penalty !== undefined && presence_penalty >= -2 && presence_penalty <= 2)
+              ? presence_penalty
+              : undefined,
+        stream: !payload.tools,
+        temperature: (temperature !== undefined && temperature >= 0 && temperature < 2) ? temperature : undefined,
+        ...(model.startsWith('qwen-vl') ? {
+          top_p: (top_p !== undefined && top_p > 0 && top_p <= 1) ? top_p : undefined,
+        } : {
+          enable_search: true,
+          top_p: (top_p !== undefined && top_p > 0 && top_p < 1) ? top_p : undefined,
+        }),
+      } as any;
+    },
+    handleStream: QwenAIStream,
+  },
+  debug: {
+    chatCompletion: () => process.env.DEBUG_QWEN_CHAT_COMPLETION === '1',
+  },
+  provider: ModelProvider.Qwen,
+});

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

@@ -2,20 +2,17 @@
 import OpenAI from 'openai';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import {
-  ChatStreamCallbacks,
-  LobeOpenAICompatibleRuntime,
-  ModelProvider,
-} from '@/libs/agent-runtime';
+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 { LobeSparkAI } from './index';
 
 const provider = ModelProvider.Spark;
 const defaultBaseURL = 'https://spark-api-open.xf-yun.com/v1';
-
-const bizErrorType = 'ProviderBizError';
-const invalidErrorType = 'InvalidProviderAPIKey';
+const bizErrorType = AgentRuntimeErrorType.ProviderBizError;
+const invalidErrorType = AgentRuntimeErrorType.InvalidProviderAPIKey;
 
 // Mock the console.error to avoid polluting test output
 vi.spyOn(console, 'error').mockImplementation(() => {});
@@ -46,7 +43,7 @@ describe('LobeSparkAI', () => {
 
   describe('chat', () => {
     describe('Error', () => {
-      it('should return OpenAIBizError with an openai error response when OpenAI.APIError is thrown', async () => {
+      it('should return QwenBizError with an openai error response when OpenAI.APIError is thrown', async () => {
         // Arrange
         const apiError = new OpenAI.APIError(
           400,
@@ -66,8 +63,8 @@ describe('LobeSparkAI', () => {
         try {
           await instance.chat({
             messages: [{ content: 'Hello', role: 'user' }],
-            model: 'general',
-            temperature: 0,
+            model: 'max-32k',
+            temperature: 0.999,
           });
         } catch (e) {
           expect(e).toEqual({
@@ -82,7 +79,7 @@ describe('LobeSparkAI', () => {
         }
       });
 
-      it('should throw AgentRuntimeError with NoOpenAIAPIKey if no apiKey is provided', async () => {
+      it('should throw AgentRuntimeError with InvalidQwenAPIKey if no apiKey is provided', async () => {
         try {
           new LobeSparkAI({});
         } catch (e) {
@@ -90,7 +87,7 @@ describe('LobeSparkAI', () => {
         }
       });
 
-      it('should return OpenAIBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
+      it('should return QwenBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
         // Arrange
         const errorInfo = {
           stack: 'abc',
@@ -106,8 +103,8 @@ describe('LobeSparkAI', () => {
         try {
           await instance.chat({
             messages: [{ content: 'Hello', role: 'user' }],
-            model: 'general',
-            temperature: 0,
+            model: 'max-32k',
+            temperature: 0.999,
           });
         } catch (e) {
           expect(e).toEqual({
@@ -122,7 +119,7 @@ describe('LobeSparkAI', () => {
         }
       });
 
-      it('should return OpenAIBizError with an cause response with desensitize Url', async () => {
+      it('should return QwenBizError with an cause response with desensitize Url', async () => {
         // Arrange
         const errorInfo = {
           stack: 'abc',
@@ -142,8 +139,8 @@ describe('LobeSparkAI', () => {
         try {
           await instance.chat({
             messages: [{ content: 'Hello', role: 'user' }],
-            model: 'general',
-            temperature: 0,
+            model: 'max-32k',
+            temperature: 0.999,
           });
         } catch (e) {
           expect(e).toEqual({
@@ -158,23 +155,22 @@ describe('LobeSparkAI', () => {
         }
       });
 
-      it('should throw an InvalidSparkAPIKey error type on 401 status code', async () => {
+      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('Unauthorized') as any;
+        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: 'general',
-            temperature: 0,
+            model: 'max-32k',
+            temperature: 0.999,
           });
         } catch (e) {
-          // Expect the chat method to throw an error with InvalidSparkAPIKey
           expect(e).toEqual({
             endpoint: defaultBaseURL,
-            error: new Error('Unauthorized'),
+            error: new Error('InvalidApiKey'),
             errorType: invalidErrorType,
             provider,
           });
@@ -191,8 +187,8 @@ describe('LobeSparkAI', () => {
         try {
           await instance.chat({
             messages: [{ content: 'Hello', role: 'user' }],
-            model: 'general',
-            temperature: 0,
+            model: 'max-32k',
+            temperature: 0.999,
           });
         } catch (e) {
           expect(e).toEqual({
@@ -239,9 +235,9 @@ describe('LobeSparkAI', () => {
         // 假设的测试函数调用，你可能需要根据实际情况调整
         await instance.chat({
           messages: [{ content: 'Hello', role: 'user' }],
-          model: 'general',
+          model: 'max-32k',
           stream: true,
-          temperature: 0,
+          temperature: 0.999,
         });
 
         // 验证 debugStream 被调用

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

@@ -1,9 +1,13 @@
 import { ModelProvider } from '../types';
 import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
 
+import { transformSparkResponseToStream, SparkAIStream } from '../utils/streams';
+
 export const LobeSparkAI = LobeOpenAICompatibleFactory({
   baseURL: 'https://spark-api-open.xf-yun.com/v1',
   chatCompletion: {
+    handleStream: SparkAIStream,
+    handleTransformResponseToStream: transformSparkResponseToStream,
     noUserId: true,
   },
   debug: {