@lobehub/chat 0.146.2 → 0.147.0

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

@@ -0,0 +1,147 @@
+import { OpenAIStream, StreamingTextResponse } from 'ai';
+import OpenAI, { ClientOptions } from 'openai';
+
+import { LOBE_DEFAULT_MODEL_LIST } from '@/config/modelProviders';
+import { ChatModelCard } from '@/types/llm';
+
+import { LobeRuntimeAI } from '../../BaseAI';
+import { ILobeAgentRuntimeErrorType } from '../../error';
+import { ChatCompetitionOptions, ChatStreamPayload } from '../../types';
+import { AgentRuntimeError } from '../createError';
+import { debugStream } from '../debugStream';
+import { desensitizeUrl } from '../desensitizeUrl';
+import { handleOpenAIError } from '../handleOpenAIError';
+
+// the model contains the following keywords is not a chat model, so we should filter them out
+const CHAT_MODELS_BLOCK_LIST = [
+  'embedding',
+  'davinci',
+  'cuire',
+  'moderation',
+  'ada',
+  'babbage',
+  'tts',
+  'whisper',
+  'dall-e',
+];
+
+interface OpenAICompatibleFactoryOptions {
+  baseURL?: string;
+  chatCompletion?: {
+    handlePayload?: (payload: ChatStreamPayload) => OpenAI.ChatCompletionCreateParamsStreaming;
+  };
+  constructorOptions?: ClientOptions;
+  debug?: {
+    chatCompletion: () => boolean;
+  };
+  errorType: {
+    bizError: ILobeAgentRuntimeErrorType;
+    invalidAPIKey: ILobeAgentRuntimeErrorType;
+  };
+  models?: {
+    transformModel?: (model: OpenAI.Model) => ChatModelCard;
+  };
+  provider: string;
+}
+
+export const LobeOpenAICompatibleFactory = ({
+  provider,
+  baseURL: DEFAULT_BASE_URL,
+  errorType: ErrorType,
+  debug,
+  constructorOptions,
+  chatCompletion,
+  models,
+}: OpenAICompatibleFactoryOptions) =>
+  class LobeOpenAICompatibleAI implements LobeRuntimeAI {
+    client: OpenAI;
+
+    baseURL: string;
+
+    constructor({ apiKey, baseURL = DEFAULT_BASE_URL, ...res }: ClientOptions) {
+      if (!apiKey) throw AgentRuntimeError.createError(ErrorType.invalidAPIKey);
+
+      this.client = new OpenAI({ apiKey, baseURL, ...constructorOptions, ...res });
+      this.baseURL = this.client.baseURL;
+    }
+
+    async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
+      try {
+        const postPayload = chatCompletion?.handlePayload
+          ? chatCompletion.handlePayload(payload)
+          : (payload as unknown as OpenAI.ChatCompletionCreateParamsStreaming);
+
+        const response = await this.client.chat.completions.create(postPayload, {
+          // https://github.com/lobehub/lobe-chat/pull/318
+          headers: { Accept: '*/*' },
+        });
+
+        const [prod, useForDebug] = response.tee();
+
+        if (debug?.chatCompletion?.()) {
+          debugStream(useForDebug.toReadableStream()).catch(console.error);
+        }
+
+        return new StreamingTextResponse(OpenAIStream(prod, options?.callback), {
+          headers: options?.headers,
+        });
+      } catch (error) {
+        let desensitizedEndpoint = this.baseURL;
+
+        // refs: https://github.com/lobehub/lobe-chat/issues/842
+        if (this.baseURL !== DEFAULT_BASE_URL) {
+          desensitizedEndpoint = desensitizeUrl(this.baseURL);
+        }
+
+        if ('status' in (error as any)) {
+          switch ((error as Response).status) {
+            case 401: {
+              throw AgentRuntimeError.chat({
+                endpoint: desensitizedEndpoint,
+                error: error as any,
+                errorType: ErrorType.invalidAPIKey,
+                provider: provider as any,
+              });
+            }
+
+            default: {
+              break;
+            }
+          }
+        }
+
+        const { errorResult, RuntimeError } = handleOpenAIError(error);
+
+        throw AgentRuntimeError.chat({
+          endpoint: desensitizedEndpoint,
+          error: errorResult,
+          errorType: RuntimeError || ErrorType.bizError,
+          provider: provider as any,
+        });
+      }
+    }
+
+    async models() {
+      const list = await this.client.models.list();
+
+      return list.data
+        .filter((model) => {
+          return CHAT_MODELS_BLOCK_LIST.every(
+            (keyword) => !model.id.toLowerCase().includes(keyword),
+          );
+        })
+        .map((item) => {
+          if (models?.transformModel) {
+            return models.transformModel(item);
+          }
+
+          const knownModel = LOBE_DEFAULT_MODEL_LIST.find((model) => model.id === item.id);
+
+          if (knownModel) return knownModel;
+
+          return { id: item.id };
+        })
+
+        .filter(Boolean) as ChatModelCard[];
+    }
+  };

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

@@ -0,0 +1,350 @@
+// @vitest-environment node
+import OpenAI from 'openai';
+import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ChatStreamCallbacks, LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
+
+import * as debugStreamModule from '../utils/debugStream';
+import { LobeZeroOneAI } from './index';
+
+const provider = 'zeroone';
+const defaultBaseURL = 'https://api.lingyiwanwu.com/v1';
+const bizErrorType = 'ZeroOneBizError';
+const invalidErrorType = 'InvalidZeroOneAPIKey';
+
+// Mock the console.error to avoid polluting test output
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+let instance: LobeOpenAICompatibleRuntime;
+
+beforeEach(() => {
+  instance = new LobeZeroOneAI({ apiKey: 'test' });
+
+  // 使用 vi.spyOn 来模拟 chat.completions.create 方法
+  vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+    new ReadableStream() as any,
+  );
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('LobeZeroOneAI', () => {
+  describe('init', () => {
+    it('should correctly initialize with an API key', async () => {
+      const instance = new LobeZeroOneAI({ apiKey: 'test_api_key' });
+      expect(instance).toBeInstanceOf(LobeZeroOneAI);
+      expect(instance.baseURL).toEqual(defaultBaseURL);
+    });
+  });
+
+  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: 'mistralai/mistral-7b-instruct:free',
+        temperature: 0,
+      });
+
+      // Assert
+      expect(result).toBeInstanceOf(Response);
+    });
+
+    it('should call ZeroOne 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: 'mistralai/mistral-7b-instruct:free',
+        temperature: 0.7,
+        top_p: 1,
+      });
+
+      // Assert
+      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+        {
+          max_tokens: 1024,
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'mistralai/mistral-7b-instruct:free',
+          temperature: 0.7,
+          top_p: 1,
+        },
+        { headers: { Accept: '*/*' } },
+      );
+      expect(result).toBeInstanceOf(Response);
+    });
+
+    describe('Error', () => {
+      it('should return OpenRouterBizError 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: 'mistralai/mistral-7b-instruct:free',
+            temperature: 0,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: defaultBaseURL,
+            error: {
+              error: { message: 'Bad Request' },
+              status: 400,
+            },
+            errorType: bizErrorType,
+            provider,
+          });
+        }
+      });
+
+      it('should throw AgentRuntimeError with InvalidOpenRouterAPIKey if no apiKey is provided', async () => {
+        try {
+          new LobeZeroOneAI({});
+        } catch (e) {
+          expect(e).toEqual({ errorType: invalidErrorType });
+        }
+      });
+
+      it('should return OpenRouterBizError 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: 'mistralai/mistral-7b-instruct:free',
+            temperature: 0,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: defaultBaseURL,
+            error: {
+              cause: { message: 'api is undefined' },
+              stack: 'abc',
+            },
+            errorType: bizErrorType,
+            provider,
+          });
+        }
+      });
+
+      it('should return OpenRouterBizError 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 LobeZeroOneAI({
+          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: 'mistralai/mistral-7b-instruct:free',
+            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 InvalidOpenRouterAPIKey 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: 'mistralai/mistral-7b-instruct:free',
+            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: 'mistralai/mistral-7b-instruct:free',
+            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('LobeZeroOneAI chat with callback and headers', () => {
+      it('should handle callback and headers correctly', async () => {
+        // 模拟 chat.completions.create 方法返回一个可读流
+        const mockCreateMethod = vi
+          .spyOn(instance['client'].chat.completions, 'create')
+          .mockResolvedValue(
+            new ReadableStream({
+              start(controller) {
+                controller.enqueue({
+                  id: 'chatcmpl-8xDx5AETP8mESQN7UB30GxTN2H1SO',
+                  object: 'chat.completion.chunk',
+                  created: 1709125675,
+                  model: 'mistralai/mistral-7b-instruct:free',
+                  system_fingerprint: 'fp_86156a94a0',
+                  choices: [
+                    { index: 0, delta: { content: 'hello' }, logprobs: null, finish_reason: null },
+                  ],
+                });
+                controller.close();
+              },
+            }) as any,
+          );
+
+        // 准备 callback 和 headers
+        const mockCallback: ChatStreamCallbacks = {
+          onStart: vi.fn(),
+          onToken: vi.fn(),
+        };
+        const mockHeaders = { 'Custom-Header': 'TestValue' };
+
+        // 执行测试
+        const result = await instance.chat(
+          {
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'mistralai/mistral-7b-instruct:free',
+            temperature: 0,
+          },
+          { callback: mockCallback, headers: mockHeaders },
+        );
+
+        // 验证 callback 被调用
+        await result.text(); // 确保流被消费
+        expect(mockCallback.onStart).toHaveBeenCalled();
+        expect(mockCallback.onToken).toHaveBeenCalledWith('hello');
+
+        // 验证 headers 被正确传递
+        expect(result.headers.get('Custom-Header')).toEqual('TestValue');
+
+        // 清理
+        mockCreateMethod.mockRestore();
+      });
+    });
+
+    describe('DEBUG', () => {
+      it('should call debugStream and return StreamingTextResponse when DEBUG_ZEROONE_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_ZEROONE_CHAT_COMPLETION;
+
+        // 模拟环境变量
+        process.env.DEBUG_ZEROONE_CHAT_COMPLETION = '1';
+        vi.spyOn(debugStreamModule, 'debugStream').mockImplementation(() => Promise.resolve());
+
+        // 执行测试
+        // 运行你的测试函数，确保它会在条件满足时调用 debugStream
+        // 假设的测试函数调用，你可能需要根据实际情况调整
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'mistralai/mistral-7b-instruct:free',
+          temperature: 0,
+        });
+
+        // 验证 debugStream 被调用
+        expect(debugStreamModule.debugStream).toHaveBeenCalled();
+
+        // 恢复原始环境变量值
+        process.env.DEBUG_ZEROONE_CHAT_COMPLETION = originalDebugValue;
+      });
+    });
+  });
+});

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

@@ -1,78 +1,15 @@
-import { OpenAIStream, StreamingTextResponse } from 'ai';
-import OpenAI, { ClientOptions } from 'openai';
-
-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 { desensitizeUrl } from '../utils/desensitizeUrl';
-import { handleOpenAIError } from '../utils/handleOpenAIError';
-
-const DEFAULT_BASE_URL = 'https://api.lingyiwanwu.com/v1';
-
-export class LobeZeroOneAI implements LobeRuntimeAI {
-  private client: OpenAI;
-
-  baseURL: string;
-
-  constructor({ apiKey, baseURL = DEFAULT_BASE_URL, ...res }: ClientOptions) {
-    if (!apiKey) throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidZeroOneAPIKey);
-
-    this.client = new OpenAI({ apiKey, baseURL, ...res });
-    this.baseURL = this.client.baseURL;
-  }
-
-  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
-    try {
-      const response = await this.client.chat.completions.create(
-        payload as unknown as OpenAI.ChatCompletionCreateParamsStreaming,
-      );
-      const [prod, debug] = response.tee();
-
-      if (process.env.DEBUG_ZEROONE_CHAT_COMPLETION === '1') {
-        debugStream(debug.toReadableStream()).catch(console.error);
-      }
-
-      return new StreamingTextResponse(OpenAIStream(prod, options?.callback), {
-        headers: options?.headers,
-      });
-    } catch (error) {
-      let desensitizedEndpoint = this.baseURL;
-
-      if (this.baseURL !== DEFAULT_BASE_URL) {
-        desensitizedEndpoint = desensitizeUrl(this.baseURL);
-      }
-
-      if ('status' in (error as any)) {
-        switch ((error as Response).status) {
-          case 401: {
-            throw AgentRuntimeError.chat({
-              endpoint: desensitizedEndpoint,
-              error: error as any,
-              errorType: AgentRuntimeErrorType.InvalidZeroOneAPIKey,
-              provider: ModelProvider.ZeroOne,
-            });
-          }
-
-          default: {
-            break;
-          }
-        }
-      }
-
-      const { errorResult, RuntimeError } = handleOpenAIError(error);
-
-      const errorType = RuntimeError || AgentRuntimeErrorType.ZeroOneBizError;
-
-      throw AgentRuntimeError.chat({
-        endpoint: desensitizedEndpoint,
-        error: errorResult,
-        errorType,
-        provider: ModelProvider.ZeroOne,
-      });
-    }
-  }
-}
-
-export default LobeZeroOneAI;
+import { ModelProvider } from '../types';
+import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
+
+export const LobeZeroOneAI = LobeOpenAICompatibleFactory({
+  baseURL: 'https://api.lingyiwanwu.com/v1',
+  debug: {
+    chatCompletion: () => process.env.DEBUG_ZEROONE_CHAT_COMPLETION === '1',
+  },
+  errorType: {
+    bizError: AgentRuntimeErrorType.ZeroOneBizError,
+    invalidAPIKey: AgentRuntimeErrorType.InvalidZeroOneAPIKey,
+  },
+  provider: ModelProvider.ZeroOne,
+});

package/src/locales/default/common.ts

@@ -1,18 +1,7 @@
 export default {
-  ModelSelect: {
-    featureTag: {
-      custom: '自定义模型，默认设定同时支持函数调用与视觉识别，请根据实际情况验证上述能力的可用性',
-      file: '该模型支持上传文件读取与识别',
-      functionCall: '该模型支持函数调用（Function Call）',
-      tokens: '该模型单个会话最多支持 {{tokens}} Tokens',
-      vision: '该模型支持视觉识别',
-    },
-  },
   about: '关于',
   advanceSettings: '高级设置',
-
   appInitializing: 'LobeChat 启动中，请耐心等待...',
-
   autoGenerate: '自动补全',
   autoGenerateTooltip: '基于提示词自动补全助手描述',
   cancel: '取消',
@@ -97,23 +86,6 @@ export default {
     'zh-TW': '繁体中文',
   },
   layoutInitializing: '正在加载布局...',
-  modelProvider: {
-    anthropic: 'Anthropic',
-    azure: 'Azure',
-    bedrock: 'AWS Bedrock',
-    google: 'Google',
-    groq: 'Groq',
-    mistral: 'Mistral AI',
-    moonshot: 'Moonshot AI',
-    ollama: 'Ollama',
-    oneapi: 'One API',
-    openai: 'OpenAI',
-    openrouter: 'OpenRouter',
-    perplexity: 'Perplexity',
-    togetherai: 'TogetherAI',
-    zeroone: '01.AI 零一万物',
-    zhipu: '智谱AI',
-  },
   noDescription: '暂无描述',
   oauth: 'SSO 登录',
   ok: '确定',

package/src/locales/default/components.ts

@@ -0,0 +1,15 @@
+export default {
+  ModelSelect: {
+    featureTag: {
+      custom: '自定义模型，默认设定同时支持函数调用与视觉识别，请根据实际情况验证上述能力的可用性',
+      file: '该模型支持上传文件读取与识别',
+      functionCall: '该模型支持函数调用（Function Call）',
+      tokens: '该模型单个会话最多支持 {{tokens}} Tokens',
+      vision: '该模型支持视觉识别',
+    },
+  },
+  ModelSwitchPanel: {
+    emptyModel: '没有启用的模型，请前往设置开启',
+    provider: '提供商',
+  },
+};