@lobehub/chat 0.155.9 → 0.156.1

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

@@ -1,85 +1,37 @@
-import { OpenAIStream, StreamingTextResponse } from 'ai';
-import OpenAI, { ClientOptions } from 'openai';
+import OpenAI 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';
+import { ChatStreamPayload, ModelProvider } from '../types';
+import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
 
-const DEFAULT_BASE_URL = 'https://api.perplexity.ai';
-
-export class LobePerplexityAI implements LobeRuntimeAI {
-  private client: OpenAI;
-
-  baseURL: string;
-
-  constructor({ apiKey, baseURL = DEFAULT_BASE_URL, ...res }: ClientOptions) {
-    if (!apiKey) throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidPerplexityAPIKey);
-
-    this.client = new OpenAI({ apiKey, baseURL, ...res });
-    this.baseURL = this.client.baseURL;
-  }
-
-  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
-    try {
+export const LobePerplexityAI = LobeOpenAICompatibleFactory({
+  baseURL: 'https://api.perplexity.ai',
+  chatCompletion: {
+    handlePayload: (payload: ChatStreamPayload) => {
       // Set a default frequency penalty value greater than 0
-      const defaultFrequencyPenalty = 0.1;
-      const chatPayload = {
-        ...payload,
-        frequency_penalty: payload.frequency_penalty || defaultFrequencyPenalty,
-      };
-      const response = await this.client.chat.completions.create(
-        chatPayload as unknown as OpenAI.ChatCompletionCreateParamsStreaming,
-        { signal: options?.signal },
-      );
-      const [prod, debug] = response.tee();
-
-      if (process.env.DEBUG_PERPLEXITY_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;
+      const { presence_penalty, frequency_penalty, ...res } = payload;
 
-      if (this.baseURL !== DEFAULT_BASE_URL) {
-        desensitizedEndpoint = desensitizeUrl(this.baseURL);
-      }
+      let param;
 
-      if ('status' in (error as any)) {
-        switch ((error as Response).status) {
-          case 401: {
-            throw AgentRuntimeError.chat({
-              endpoint: desensitizedEndpoint,
-              error: error as any,
-              errorType: AgentRuntimeErrorType.InvalidPerplexityAPIKey,
-              provider: ModelProvider.Perplexity,
-            });
-          }
+      // Ensure we are only have one frequency_penalty or frequency_penalty
+      if (presence_penalty !== 0) {
+        param = { presence_penalty };
+      } else {
+        const defaultFrequencyPenalty = 1;
 
-          default: {
-            break;
-          }
-        }
+        param = { frequency_penalty: frequency_penalty || defaultFrequencyPenalty };
       }
 
-      const { errorResult, RuntimeError } = handleOpenAIError(error);
-
-      const errorType = RuntimeError || AgentRuntimeErrorType.PerplexityBizError;
-
-      throw AgentRuntimeError.chat({
-        endpoint: desensitizedEndpoint,
-        error: errorResult,
-        errorType,
-        provider: ModelProvider.Perplexity,
-      });
-    }
-  }
-}
-
-export default LobePerplexityAI;
+      console.log(param);
+      return { ...res, ...param } as OpenAI.ChatCompletionCreateParamsStreaming;
+    },
+  },
+  debug: {
+    chatCompletion: () => process.env.DEBUG_PERPLEXITY_CHAT_COMPLETION === '1',
+  },
+  errorType: {
+    bizError: AgentRuntimeErrorType.PerplexityBizError,
+    invalidAPIKey: AgentRuntimeErrorType.InvalidPerplexityAPIKey,
+  },
+  provider: ModelProvider.Perplexity,
+});

package/src/libs/agent-runtime/utils/anthropicHelpers.test.ts

@@ -1,7 +1,11 @@
 import { describe, expect, it } from 'vitest';
 
 import { OpenAIChatMessage, UserMessageContentPart } from '../types/chat';
-import { buildAnthropicBlock, buildAnthropicMessage } from './anthropicHelpers';
+import {
+  buildAnthropicBlock,
+  buildAnthropicMessage,
+  buildAnthropicMessages,
+} from './anthropicHelpers';
 import { parseDataUri } from './uriParser';
 
 describe('anthropicHelpers', () => {
@@ -48,4 +52,63 @@ describe('anthropicHelpers', () => {
       expect(result).toEqual({ content: [{ type: 'text', text: 'Hello!' }], role: 'assistant' });
     });
   });
+
+  describe('buildAnthropicMessages', () => {
+    it('should correctly convert OpenAI Messages to Anthropic Messages', () => {
+      const messages: OpenAIChatMessage[] = [
+        { content: 'Hello', role: 'user' },
+        { content: 'Hi', role: 'assistant' },
+      ];
+
+      const result = buildAnthropicMessages(messages);
+      expect(result).toHaveLength(2);
+      expect(result).toEqual([
+        { content: 'Hello', role: 'user' },
+        { content: 'Hi', role: 'assistant' },
+      ]);
+    });
+
+    it('messages should end with user', () => {
+      const messages: OpenAIChatMessage[] = [
+        { content: 'Hello', role: 'user' },
+        { content: 'Hello', role: 'user' },
+        { content: 'Hi', role: 'assistant' },
+      ];
+
+      const contents = buildAnthropicMessages(messages);
+
+      expect(contents).toHaveLength(4);
+      expect(contents).toEqual([
+        { content: 'Hello', role: 'user' },
+        { content: '_', role: 'assistant' },
+        { content: 'Hello', role: 'user' },
+        { content: 'Hi', role: 'assistant' },
+      ]);
+    });
+
+    it('messages should pair', () => {
+      const messages: OpenAIChatMessage[] = [
+        { content: 'a', role: 'assistant' },
+        { content: 'b', role: 'assistant' },
+        { content: 'c', role: 'assistant' },
+        { content: 'd', role: 'assistant' },
+        { content: '你好', role: 'user' },
+      ];
+
+      const contents = buildAnthropicMessages(messages);
+
+      expect(contents).toHaveLength(9);
+      expect(contents).toEqual([
+        { content: '_', role: 'user' },
+        { content: 'a', role: 'assistant' },
+        { content: '_', role: 'user' },
+        { content: 'b', role: 'assistant' },
+        { content: '_', role: 'user' },
+        { content: 'c', role: 'assistant' },
+        { content: '_', role: 'user' },
+        { content: 'd', role: 'assistant' },
+        { content: '你好', role: 'user' },
+      ]);
+    });
+  });
 });

package/src/libs/agent-runtime/utils/anthropicHelpers.ts

@@ -37,5 +37,21 @@ export const buildAnthropicMessage = (
 };
 
 export const buildAnthropicMessages = (
-  messages: OpenAIChatMessage[],
-): Anthropic.Messages.MessageParam[] => messages.map((message) => buildAnthropicMessage(message));
+  oaiMessages: OpenAIChatMessage[],
+): Anthropic.Messages.MessageParam[] => {
+  const messages: Anthropic.Messages.MessageParam[] = [];
+  let lastRole = 'assistant';
+
+  oaiMessages.forEach((message) => {
+    const anthropicMessage = buildAnthropicMessage(message);
+
+    if (lastRole === anthropicMessage.role) {
+      messages.push({ content: '_', role: lastRole === 'user' ? 'assistant' : 'user' });
+    }
+
+    lastRole = anthropicMessage.role;
+    messages.push(anthropicMessage);
+  });
+
+  return messages;
+};

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

@@ -6,7 +6,7 @@ import { ChatModelCard } from '@/types/llm';
 
 import { LobeRuntimeAI } from '../../BaseAI';
 import { ILobeAgentRuntimeErrorType } from '../../error';
-import { ChatCompetitionOptions, ChatStreamPayload } from '../../types';
+import { ChatCompetitionOptions, ChatCompletionErrorPayload, ChatStreamPayload } from '../../types';
 import { AgentRuntimeError } from '../createError';
 import { debugStream } from '../debugStream';
 import { desensitizeUrl } from '../desensitizeUrl';
@@ -28,6 +28,7 @@ const CHAT_MODELS_BLOCK_LIST = [
 interface OpenAICompatibleFactoryOptions {
   baseURL?: string;
   chatCompletion?: {
+    handleError?: (error: any) => Omit<ChatCompletionErrorPayload, 'provider'> | undefined;
     handlePayload?: (payload: ChatStreamPayload) => OpenAI.ChatCompletionCreateParamsStreaming;
   };
   constructorOptions?: ClientOptions;
@@ -113,6 +114,16 @@ export const LobeOpenAICompatibleFactory = ({
           }
         }
 
+        if (chatCompletion?.handleError) {
+          const errorResult = chatCompletion.handleError(error);
+
+          if (errorResult)
+            throw AgentRuntimeError.chat({
+              ...errorResult,
+              provider,
+            } as ChatCompletionErrorPayload);
+        }
+
         const { errorResult, RuntimeError } = handleOpenAIError(error);
 
         throw AgentRuntimeError.chat({

package/src/locales/default/error.ts

@@ -72,7 +72,7 @@ export default {
     InvalidAccessCode: '密码不正确或为空，请输入正确的访问密码，或者添加自定义 API Key',
     InvalidClerkUser: '很抱歉，你当前尚未登录，请先登录或注册账号后继续操作',
     LocationNotSupportError:
-      '很抱歉，你的所在位置不支持此模型服务，可能是由于地区限制或服务未开通。请确认当前位置是否支持使用此服务，或尝试使用其他位置信息。',
+      '很抱歉，你的所在地区不支持此模型服务，可能是由于区域限制或服务未开通。请确认当前地区是否支持使用此服务，或尝试使用切换到其他地区后重试。',
 
     OpenAIBizError: '请求 OpenAI 服务出错，请根据以下信息排查或重试',
     NoOpenAIAPIKey: 'OpenAI API Key 为空，请添加自定义 OpenAI API Key',

package/src/locales/default/modelProvider.ts

@@ -1,17 +1,11 @@
 export default {
   anthropic: {
-    endpoint: {
-      desc: '除默认地址外，必须包含 http(s)://',
-      placeholder: 'https://api.anthropic.com',
-      title: 'API 代理地址',
-    },
     title: 'Anthropic',
     token: {
       desc: '填入来自 Anthropic 的 API Key',
       placeholder: 'Anthropic API Key',
       title: 'API Key',
     },
-
     unlock: {
       description: '输入你的 Anthropic API Key 即可开始会话。应用不会记录你的 API Key',
       title: '使用自定义 Anthropic API Key',
@@ -69,11 +63,6 @@ export default {
     },
   },
   google: {
-    endpoint: {
-      desc: '除默认地址外，必须包含 http(s)://',
-      placeholder: 'https://generativelanguage.googleapis.com',
-      title: 'API 代理地址',
-    },
     title: 'Google',
     token: {
       desc: '填入来自 Google 的 API Key',
@@ -136,6 +125,7 @@ export default {
   ollama: {
     checker: {
       desc: '测试代理地址是否正确填写',
+      title: '连通性检查',
     },
     customModelName: {
       desc: '增加自定义模型，多个模型使用逗号（,）隔开',
@@ -144,8 +134,7 @@ export default {
     },
     endpoint: {
       desc: '填入 Ollama 接口代理地址，本地未额外指定可留空',
-      placeholder: 'http://127.0.0.1:11434',
-      title: '接口代理地址',
+      title: 'Ollama 服务地址',
     },
     setup: {
       cors: {
@@ -176,11 +165,6 @@ export default {
     title: 'Ollama',
   },
   openai: {
-    endpoint: {
-      desc: '除默认地址外，必须包含 http(s)://',
-      placeholder: 'https://api.openai.com/v1',
-      title: '接口代理地址',
-    },
     title: 'OpenAI',
     token: {
       desc: '使用自己的 OpenAI Key',

package/src/locales/default/setting.ts

@@ -38,7 +38,6 @@ export default {
     checker: {
       button: '检查',
       desc: '测试 Api Key 与代理地址是否正确填写',
-      ollamaDesc: '测试代理地址是否正确填写',
       pass: '检查通过',
       title: '连通性检查',
     },
@@ -99,6 +98,10 @@ export default {
       title: '模型列表',
       total: '共 {{count}} 个模型可用',
     },
+    proxyUrl: {
+      desc: '除默认地址外，必须包含 http(s)://',
+      title: 'API 代理地址',
+    },
     waitingForMore: '更多模型正在 <1>计划接入</1> 中，敬请期待 ✨',
   },
   ollama: {