@lobehub/chat 1.60.9 → 1.61.1

package/src/config/modelProviders/index.ts

@@ -40,6 +40,7 @@ import TaichuProvider from './taichu';
 import TencentcloudProvider from './tencentcloud';
 import TogetherAIProvider from './togetherai';
 import UpstageProvider from './upstage';
+import VertexAIProvider from './vertexai';
 import VLLMProvider from './vllm';
 import VolcengineProvider from './volcengine';
 import WenxinProvider from './wenxin';
@@ -102,6 +103,7 @@ export const DEFAULT_MODEL_PROVIDER_LIST = [
   AnthropicProvider,
   BedrockProvider,
   GoogleProvider,
+  VertexAIProvider,
   DeepSeekProvider,
   HuggingFaceProvider,
   OpenRouterProvider,
@@ -191,6 +193,7 @@ export { default as TaichuProviderCard } from './taichu';
 export { default as TencentCloudProviderCard } from './tencentcloud';
 export { default as TogetherAIProviderCard } from './togetherai';
 export { default as UpstageProviderCard } from './upstage';
+export { default as VertexAIProviderCard } from './vertexai';
 export { default as VLLMProviderCard } from './vllm';
 export { default as VolcengineProviderCard } from './volcengine';
 export { default as WenxinProviderCard } from './wenxin';

package/src/config/modelProviders/vertexai.ts

@@ -0,0 +1,22 @@
+import { ModelProviderCard } from '@/types/llm';
+
+// ref: https://ai.google.dev/gemini-api/docs/models/gemini
+const VertexAI: ModelProviderCard = {
+  chatModels: [],
+  checkModel: 'gemini-1.5-flash-001',
+  description:
+    'Google 的 Gemini 系列是其最先进、通用的 AI模型，由 Google DeepMind 打造，专为多模态设计，支持文本、代码、图像、音频和视频的无缝理解与处理。适用于从数据中心到移动设备的多种环境，极大提升了AI模型的效率与应用广泛性。',
+  id: 'vertexai',
+  modelsUrl: 'https://console.cloud.google.com/vertex-ai/model-garden',
+  name: 'VertexAI',
+  settings: {
+    disableBrowserRequest: true,
+    smoothing: {
+      speed: 2,
+      text: true,
+    },
+  },
+  url: 'https://cloud.google.com/vertex-ai',
+};
+
+export default VertexAI;

package/src/database/client/db.ts

@@ -201,7 +201,8 @@ export class DatabaseManager {
         const dbName = 'lobechat';
 
         // make db as web worker if worker is available
-        if (typeof Worker !== 'undefined') {
+        // https://github.com/lobehub/lobe-chat/issues/5785
+        if (typeof Worker !== 'undefined' && typeof navigator.locks !== 'undefined') {
           db = await initPgliteWorker({
             dbName,
             fsBundle: fsBundle as Blob,

package/src/features/Conversation/Error/index.tsx

@@ -14,7 +14,6 @@ import ClerkLogin from './ClerkLogin';
 import ErrorJsonViewer from './ErrorJsonViewer';
 import InvalidAPIKey from './InvalidAPIKey';
 import InvalidAccessCode from './InvalidAccessCode';
-import OpenAiBizError from './OpenAiBizError';
 
 const loading = () => <Skeleton active />;
 
@@ -34,8 +33,11 @@ const getErrorAlertConfig = (
     };
 
   switch (errorType) {
+    case ChatErrorType.SystemTimeNotMatchError:
     case AgentRuntimeErrorType.PermissionDenied:
+    case AgentRuntimeErrorType.InsufficientQuota:
     case AgentRuntimeErrorType.QuotaLimitReached:
+    case AgentRuntimeErrorType.ExceededContextWindow:
     case AgentRuntimeErrorType.LocationNotSupportError: {
       return {
         type: 'warning',
@@ -82,10 +84,6 @@ const ErrorMessageExtra = memo<{ data: ChatMessage }>(({ data }) => {
       return <PluginSettings id={data.id} plugin={data.plugin} />;
     }
 
-    case AgentRuntimeErrorType.OpenAIBizError: {
-      return <OpenAiBizError {...data} />;
-    }
-
     case AgentRuntimeErrorType.OllamaBizError: {
       return <OllamaBizError {...data} />;
     }

package/src/features/Conversation/Messages/User/MarkdownRender/ContentPreview.tsx

@@ -15,9 +15,13 @@ const useStyles = createStyles(({ css, token, isDarkMode }, displayMode: 'chat'
 
   return {
     mask: css`
+      pointer-events: none;
+
       position: absolute;
       inset-block: 0 0;
+
       width: 100%;
+
       background: linear-gradient(0deg, ${maskBgColor} 0%, transparent 50%);
     `,
   };
@@ -44,10 +48,12 @@ const ContentPreview = ({ content, id, displayMode }: ContentPreviewProps) => {
       <Flexbox padding={4}>
         <Button
           block
+          color={'default'}
           onClick={() => {
             openMessageDetail(id);
           }}
           size={'small'}
+          variant={'filled'}
         >
           {t('chatList.longMessageDetail')}
         </Button>

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

@@ -3,8 +3,12 @@
 export const AgentRuntimeErrorType = {
   AgentRuntimeError: 'AgentRuntimeError', // Agent Runtime 模块运行时错误
   LocationNotSupportError: 'LocationNotSupportError',
+
   QuotaLimitReached: 'QuotaLimitReached',
+  InsufficientQuota: 'InsufficientQuota',
+
   PermissionDenied: 'PermissionDenied',
+  ExceededContextWindow: 'ExceededContextWindow',
 
   InvalidProviderAPIKey: 'InvalidProviderAPIKey',
   ProviderBizError: 'ProviderBizError',
@@ -13,6 +17,7 @@ export const AgentRuntimeErrorType = {
   OllamaBizError: 'OllamaBizError',
 
   InvalidBedrockCredentials: 'InvalidBedrockCredentials',
+  InvalidVertexCredentials: 'InvalidVertexCredentials',
   StreamChunkError: 'StreamChunkError',
 
   InvalidGithubToken: 'InvalidGithubToken',
@@ -23,10 +28,6 @@ export const AgentRuntimeErrorType = {
    * @deprecated
    */
   NoOpenAIAPIKey: 'NoOpenAIAPIKey',
-  /**
-   * @deprecated
-   */
-  OpenAIBizError: 'OpenAIBizError',
 } as const;
 
 export const AGENT_RUNTIME_ERROR_SET = new Set<string>(Object.values(AgentRuntimeErrorType));

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

@@ -1,3 +1,4 @@
+import type { VertexAI } from '@google-cloud/vertexai';
 import {
   Content,
   FunctionCallPart,
@@ -9,6 +10,7 @@ import {
 } from '@google/generative-ai';
 
 import type { ChatModelCard } from '@/types/llm';
+import { VertexAIStream } from '@/libs/agent-runtime/utils/streams/vertex-ai';
 import { imageUrlToBase64 } from '@/utils/imageToBase64';
 import { safeParseJSON } from '@/utils/safeParseJSON';
 
@@ -56,17 +58,27 @@ function getThreshold(model: string): HarmBlockThreshold {
 
 const DEFAULT_BASE_URL = 'https://generativelanguage.googleapis.com';
 
+interface LobeGoogleAIParams {
+  apiKey?: string;
+  baseURL?: string;
+  client?: GoogleGenerativeAI | VertexAI;
+  isVertexAi?: boolean;
+}
+
 export class LobeGoogleAI implements LobeRuntimeAI {
   private client: GoogleGenerativeAI;
+  private isVertexAi: boolean;
   baseURL?: string;
   apiKey?: string;
 
-  constructor({ apiKey, baseURL }: { apiKey?: string; baseURL?: string } = {}) {
+  constructor({ apiKey, baseURL, client, isVertexAi }: LobeGoogleAIParams = {}) {
     if (!apiKey) throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey);
 
     this.client = new GoogleGenerativeAI(apiKey);
-    this.baseURL = baseURL || DEFAULT_BASE_URL;
     this.apiKey = apiKey;
+    this.client = client ? (client as GoogleGenerativeAI) : new GoogleGenerativeAI(apiKey);
+    this.baseURL = client ? undefined : baseURL || DEFAULT_BASE_URL;
+    this.isVertexAi = isVertexAi || false;
   }
 
   async chat(rawPayload: ChatStreamPayload, options?: ChatCompetitionOptions) {
@@ -117,18 +129,24 @@ export class LobeGoogleAI implements LobeRuntimeAI {
       const googleStream = convertIterableToStream(geminiStreamResult.stream);
       const [prod, useForDebug] = googleStream.tee();
 
-      if (process.env.DEBUG_GOOGLE_CHAT_COMPLETION === '1') {
+      const key = this.isVertexAi
+        ? 'DEBUG_VERTEX_AI_CHAT_COMPLETION'
+        : 'DEBUG_GOOGLE_CHAT_COMPLETION';
+
+      if (process.env[key] === '1') {
         debugStream(useForDebug).catch();
       }
 
       // Convert the response into a friendly text-stream
-      const stream = GoogleGenerativeAIStream(prod, options?.callback);
+      const Stream = this.isVertexAi ? VertexAIStream : GoogleGenerativeAIStream;
+      const stream = Stream(prod, options?.callback);
 
       // Respond with the stream
       return StreamingResponse(stream, { headers: options?.headers });
     } catch (e) {
       const err = e as Error;
 
+      console.log(err);
       const { errorType, error } = this.parseErrorMessage(err.message);
 
       throw AgentRuntimeError.chat({ error, errorType, provider: ModelProvider.Google });

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

@@ -66,6 +66,7 @@ export enum ModelProvider {
   TogetherAI = 'togetherai',
   Upstage = 'upstage',
   VLLM = 'vllm',
+  VertexAI = 'vertexai',
   Volcengine = 'volcengine',
   Wenxin = 'wenxin',
   XAI = 'xai',

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

@@ -386,6 +386,28 @@ export const LobeOpenAICompatibleFactory = <T extends Record<string, any> = any>
 
       const { errorResult, RuntimeError } = handleOpenAIError(error);
 
+      switch (errorResult.code) {
+        case 'insufficient_quota': {
+          return AgentRuntimeError.chat({
+            endpoint: desensitizedEndpoint,
+            error: errorResult,
+            errorType: AgentRuntimeErrorType.InsufficientQuota,
+            provider: provider as ModelProvider,
+          });
+        }
+
+        // content too long
+        case 'context_length_exceeded':
+        case 'string_above_max_length': {
+          return AgentRuntimeError.chat({
+            endpoint: desensitizedEndpoint,
+            error: errorResult,
+            errorType: AgentRuntimeErrorType.ExceededContextWindow,
+            provider: provider as ModelProvider,
+          });
+        }
+      }
+
       return AgentRuntimeError.chat({
         endpoint: desensitizedEndpoint,
         error: errorResult,

package/src/libs/agent-runtime/utils/streams/vertex-ai.test.ts

@@ -0,0 +1,236 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import * as uuidModule from '@/utils/uuid';
+
+import { VertexAIStream } from './vertex-ai';
+
+describe('VertexAIStream', () => {
+  it('should transform Vertex AI stream to protocol stream', async () => {
+    vi.spyOn(uuidModule, 'nanoid').mockReturnValueOnce('1');
+    const rawChunks = [
+      {
+        candidates: [
+          {
+            content: { role: 'model', parts: [{ text: '你好' }] },
+            safetyRatings: [
+              {
+                category: 'HARM_CATEGORY_HATE_SPEECH',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.06298828,
+                severity: 'HARM_SEVERY_NEGLIGIBLE',
+                severityScore: 0.10986328,
+              },
+              {
+                category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.05029297,
+                severity: 'HARM_SEVERITY_NEGLIGIBLE',
+                severityScore: 0.078125,
+              },
+              {
+                category: 'HARM_CATEGORY_HARASSMENT',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.19433594,
+                severity: 'HARM_SEVERITY_NEGLIGIBLE',
+                severityScore: 0.16015625,
+              },
+              {
+                category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.059326172,
+                severity: 'HARM_SEVERITY_NEGLIGIBLE',
+                severityScore: 0.064453125,
+              },
+            ],
+            index: 0,
+          },
+        ],
+        usageMetadata: {},
+        modelVersion: 'gemini-1.5-flash-001',
+      },
+      {
+        candidates: [
+          {
+            content: { role: 'model', parts: [{ text: '！ 😊' }] },
+            safetyRatings: [
+              {
+                category: 'HARM_CATEGORY_HATE_SPEECH',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.052734375,
+                severity: 'HARM_SEVRITY_NEGLIGIBLE',
+                severityScore: 0.08642578,
+              },
+              {
+                category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.071777344,
+                severity: 'HARM_SEVERITY_NEGLIGIBLE',
+                severityScore: 0.095214844,
+              },
+              {
+                category: 'HARM_CATEGORY_HARASSMENT',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.1640625,
+                severity: 'HARM_SEVERITY_NEGLIGIBLE',
+                severityScore: 0.10498047,
+              },
+              {
+                category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.075683594,
+                severity: 'HARM_SEVERITY_NEGLIGIBLE',
+                severityScore: 0.053466797,
+              },
+            ],
+            index: 0,
+          },
+        ],
+        modelVersion: 'gemini-1.5-flash-001',
+      },
+    ];
+
+    const mockGoogleStream = new ReadableStream({
+      start(controller) {
+        rawChunks.forEach((chunk) => controller.enqueue(chunk));
+
+        controller.close();
+      },
+    });
+
+    const onStartMock = vi.fn();
+    const onTextMock = vi.fn();
+    const onTokenMock = vi.fn();
+    const onToolCallMock = vi.fn();
+    const onCompletionMock = vi.fn();
+
+    const protocolStream = VertexAIStream(mockGoogleStream, {
+      onStart: onStartMock,
+      onText: onTextMock,
+      onToken: onTokenMock,
+      onToolCall: onToolCallMock,
+      onCompletion: onCompletionMock,
+    });
+
+    const decoder = new TextDecoder();
+    const chunks = [];
+
+    // @ts-ignore
+    for await (const chunk of protocolStream) {
+      chunks.push(decoder.decode(chunk, { stream: true }));
+    }
+
+    expect(chunks).toEqual([
+      // text
+      'id: chat_1\n',
+      'event: text\n',
+      `data: "你好"\n\n`,
+
+      // text
+      'id: chat_1\n',
+      'event: text\n',
+      `data: "！ 😊"\n\n`,
+    ]);
+
+    expect(onStartMock).toHaveBeenCalledTimes(1);
+    expect(onTokenMock).toHaveBeenCalledTimes(2);
+    expect(onCompletionMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('tool_calls', async () => {
+    vi.spyOn(uuidModule, 'nanoid').mockReturnValueOnce('1');
+    const rawChunks = [
+      {
+        candidates: [
+          {
+            content: {
+              role: 'model',
+              parts: [
+                {
+                  functionCall: {
+                    name: 'realtime-weather____fetchCurrentWeather',
+                    args: { city: '杭州' },
+                  },
+                },
+              ],
+            },
+            finishReason: 'STOP',
+            safetyRatings: [
+              {
+                category: 'HARM_CATERY_HATE_SPEECH',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.09814453,
+                severity: 'HARM_SEVERITY_NEGLIGIBLE',
+                severityScore: 0.07470703,
+              },
+              {
+                category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.1484375,
+                severity: 'HARM_SEVERITY_NEGLIGIBLE',
+                severityScore: 0.15136719,
+              },
+              {
+                category: 'HARM_CATEGORY_HARASSMENT',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.11279297,
+                severity: 'HARM_SEVERITY_NEGLIGIBLE',
+                severityScore: 0.10107422,
+              },
+              {
+                category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
+                probability: 'NEGLIGIBLE',
+                probabilityScore: 0.048828125,
+                severity: 'HARM_SEVERITY_NEGLIGIBLE',
+                severityScore: 0.05493164,
+              },
+            ],
+            index: 0,
+          },
+        ],
+        usageMetadata: { promptTokenCount: 95, candidatesTokenCount: 9, totalTokenCount: 104 },
+        modelVersion: 'gemini-1.5-flash-001',
+      },
+    ];
+
+    const mockGoogleStream = new ReadableStream({
+      start(controller) {
+        rawChunks.forEach((chunk) => controller.enqueue(chunk));
+
+        controller.close();
+      },
+    });
+
+    const onStartMock = vi.fn();
+    const onTextMock = vi.fn();
+    const onTokenMock = vi.fn();
+    const onToolCallMock = vi.fn();
+    const onCompletionMock = vi.fn();
+
+    const protocolStream = VertexAIStream(mockGoogleStream, {
+      onStart: onStartMock,
+      onText: onTextMock,
+      onToken: onTokenMock,
+      onToolCall: onToolCallMock,
+      onCompletion: onCompletionMock,
+    });
+
+    const decoder = new TextDecoder();
+    const chunks = [];
+
+    // @ts-ignore
+    for await (const chunk of protocolStream) {
+      chunks.push(decoder.decode(chunk, { stream: true }));
+    }
+
+    expect(chunks).toEqual([
+      // text
+      'id: chat_1\n',
+      'event: tool_calls\n',
+      `data: [{"function":{"arguments":"{\\"city\\":\\"杭州\\"}","name":"realtime-weather____fetchCurrentWeather"},"id":"realtime-weather____fetchCurrentWeather_0","index":0,"type":"function"}]\n\n`,
+    ]);
+
+    expect(onStartMock).toHaveBeenCalledTimes(1);
+    expect(onToolCallMock).toHaveBeenCalledTimes(1);
+    expect(onCompletionMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/libs/agent-runtime/utils/streams/vertex-ai.ts

@@ -0,0 +1,75 @@
+import { EnhancedGenerateContentResponse, GenerateContentResponse } from '@google/generative-ai';
+
+import { nanoid } from '@/utils/uuid';
+
+import { ChatStreamCallbacks } from '../../types';
+import {
+  StreamProtocolChunk,
+  StreamStack,
+  createCallbacksTransformer,
+  createSSEProtocolTransformer,
+  generateToolCallId,
+} from './protocol';
+
+const transformVertexAIStream = (
+  chunk: GenerateContentResponse,
+  stack: StreamStack,
+): StreamProtocolChunk => {
+  // maybe need another structure to add support for multiple choices
+  const candidates = chunk.candidates;
+
+  if (!candidates)
+    return {
+      data: '',
+      id: stack?.id,
+      type: 'text',
+    };
+
+  const item = candidates[0];
+  if (item.content) {
+    const part = item.content.parts[0];
+
+    if (part.functionCall) {
+      const functionCall = part.functionCall;
+
+      return {
+        data: [
+          {
+            function: {
+              arguments: JSON.stringify(functionCall.args),
+              name: functionCall.name,
+            },
+            id: generateToolCallId(0, functionCall.name),
+            index: 0,
+            type: 'function',
+          },
+        ],
+        id: stack?.id,
+        type: 'tool_calls',
+      };
+    }
+
+    return {
+      data: part.text,
+      id: stack?.id,
+      type: 'text',
+    };
+  }
+
+  return {
+    data: '',
+    id: stack?.id,
+    type: 'stop',
+  };
+};
+
+export const VertexAIStream = (
+  rawStream: ReadableStream<EnhancedGenerateContentResponse>,
+  callbacks?: ChatStreamCallbacks,
+) => {
+  const streamStack: StreamStack = { id: 'chat_' + nanoid() };
+
+  return rawStream
+    .pipeThrough(createSSEProtocolTransformer(transformVertexAIStream, streamStack))
+    .pipeThrough(createCallbacksTransformer(callbacks));
+};

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

@@ -0,0 +1,23 @@
+import { VertexAI, VertexInit } from '@google-cloud/vertexai';
+
+import { AgentRuntimeError, AgentRuntimeErrorType, LobeGoogleAI } from '@/libs/agent-runtime';
+
+export class LobeVertexAI extends LobeGoogleAI {
+  static initFromVertexAI(params?: VertexInit) {
+    try {
+      const client = new VertexAI({ ...params });
+
+      return new LobeGoogleAI({ apiKey: 'avoid-error', client, isVertexAi: true });
+    } catch (e) {
+      const err = e as Error;
+
+      if (err.name === 'IllegalArgumentError') {
+        throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidVertexCredentials, {
+          message: err.message,
+        });
+      }
+
+      throw e;
+    }
+  }
+}

package/src/locales/default/error.ts

@@ -90,8 +90,12 @@ export default {
 
     InvalidAccessCode: '密码不正确或为空，请输入正确的访问密码，或者添加自定义 API Key',
     InvalidClerkUser: '很抱歉，你当前尚未登录，请先登录或注册账号后继续操作',
+    SystemTimeNotMatchError: '很抱歉，您的系统时间和服务器不匹配，请检查您的系统时间后重试',
     LocationNotSupportError:
       '很抱歉，你的所在地区不支持此模型服务，可能是由于区域限制或服务未开通。请确认当前地区是否支持使用此服务，或尝试使用切换到其他地区后重试。',
+    InsufficientQuota:
+      '很抱歉，该密钥的配额(quota)已达上限，请检查账户余额是否充足，或增大密钥配额后再试',
+    ExceededContextWindow: '当前请求内容超出模型可处理的长度，请减少内容量后重试',
     QuotaLimitReached:
       '很抱歉，当前 Token 用量或请求次数已达该密钥的配额(quota)上限，请增加该密钥的配额或稍后再试',
     PermissionDenied: '很抱歉，你没有权限访问该服务，请检查你的密钥是否有访问权限',
@@ -101,11 +105,8 @@ export default {
      * @deprecated
      */
     NoOpenAIAPIKey: 'OpenAI API Key 不正确或为空，请添加自定义 OpenAI API Key',
-    /**
-     * @deprecated
-     */
-    OpenAIBizError: '请求 OpenAI 服务出错，请根据以下信息排查或重试',
 
+    InvalidVertexCredentials: 'Vertex 鉴权未通过，请检查鉴权凭证后重试',
     InvalidBedrockCredentials: 'Bedrock 鉴权未通过，请检查 AccessKeyId/SecretAccessKey 后重试',
     StreamChunkError:
       '流式请求的消息块解析错误，请检查当前 API 接口是否符合标准规范，或联系你的 API 供应商咨询',

package/src/locales/default/modelProvider.ts

@@ -325,6 +325,13 @@ export default {
     tooltip: '更新服务商基础配置',
     updateSuccess: '更新成功',
   },
+  vertexai: {
+    apiKey: {
+      desc: '填入你的 Vertex Ai Keys',
+      placeholder: `{ "type": "service_account", "project_id": "xxx", "private_key_id": ... }`,
+      title: 'Vertex AI Keys',
+    },
+  },
   zeroone: {
     title: '01.AI 零一万物',
   },

package/src/types/fetch.ts

@@ -13,6 +13,7 @@ export const ChatErrorType = {
   OllamaServiceUnavailable: 'OllamaServiceUnavailable', // 未启动/检测到 Ollama 服务
   PluginFailToTransformArguments: 'PluginFailToTransformArguments',
   UnknownChatFetchError: 'UnknownChatFetchError',
+  SystemTimeNotMatchError: 'SystemTimeNotMatchError',
 
   // ******* 客户端错误 ******* //
   BadRequest: 400,

package/src/types/user/settings/keyVaults.ts

@@ -68,6 +68,7 @@ export interface UserKeyVaults {
   tencentcloud?: OpenAICompatibleKeyVault;
   togetherai?: OpenAICompatibleKeyVault;
   upstage?: OpenAICompatibleKeyVault;
+  vertexai?: OpenAICompatibleKeyVault;
   vllm?: OpenAICompatibleKeyVault;
   volcengine?: OpenAICompatibleKeyVault;
   wenxin?: OpenAICompatibleKeyVault;

package/src/utils/errorResponse.test.ts

@@ -33,12 +33,6 @@ describe('createErrorResponse', () => {
   });
 
   describe('Provider Biz Error', () => {
-    it('returns a 471 status for OpenAIBizError error type', () => {
-      const errorType = AgentRuntimeErrorType.OpenAIBizError;
-      const response = createErrorResponse(errorType);
-      expect(response.status).toBe(471);
-    });
-
     it('returns a 471 status for ProviderBizError error type', () => {
       const errorType = AgentRuntimeErrorType.ProviderBizError;
       const response = createErrorResponse(errorType);
@@ -50,12 +44,6 @@ describe('createErrorResponse', () => {
       const response = createErrorResponse(errorType);
       expect(response.status).toBe(470);
     });
-
-    it('returns a 471 status for OpenAIBizError error type', () => {
-      const errorType = AgentRuntimeErrorType.OpenAIBizError;
-      const response = createErrorResponse(errorType as any);
-      expect(response.status).toBe(471);
-    });
   });
 
   // 测试状态码不在200-599范围内的情况