@lobehub/chat 1.60.9 → 1.61.0

package/src/config/aiModels/vertexai.ts

@@ -0,0 +1,200 @@
+import { AIChatModelCard } from '@/types/aiModel';
+
+// ref: https://ai.google.dev/gemini-api/docs/models/gemini
+const vertexaiChatModels: AIChatModelCard[] = [
+  {
+    abilities: {
+      functionCall: true,
+      vision: true,
+    },
+    contextWindowTokens: 2_097_152 + 8192,
+    description:
+      'Gemini 2.0 Pro Experimental 是 Google 最新的实验性多模态AI模型，与历史版本相比有一定的质量提升，特别是对于世界知识、代码和长上下文。',
+    displayName: 'Gemini 2.0 Pro Experimental 02-05',
+    enabled: true,
+    id: 'gemini-2.0-pro-exp-02-05',
+    maxOutput: 8192,
+    pricing: {
+      cachedInput: 0,
+      input: 0,
+      output: 0,
+    },
+    releasedAt: '2025-02-05',
+    type: 'chat',
+  },
+  {
+    abilities: {
+      functionCall: true,
+      vision: true,
+    },
+    contextWindowTokens: 1_048_576 + 8192,
+    description:
+      'Gemini 2.0 Flash 提供下一代功能和改进，包括卓越的速度、原生工具使用、多模态生成和1M令牌上下文窗口。',
+    displayName: 'Gemini 2.0 Flash',
+    enabled: true,
+    id: 'gemini-2.0-flash',
+    maxOutput: 8192,
+    pricing: {
+      cachedInput: 0.025,
+      input: 0.1,
+      output: 0.4,
+    },
+    releasedAt: '2025-02-05',
+    type: 'chat',
+  },
+  {
+    abilities: {
+      functionCall: true,
+      vision: true,
+    },
+    contextWindowTokens: 1_048_576 + 8192,
+    description:
+      'Gemini 2.0 Flash 提供下一代功能和改进，包括卓越的速度、原生工具使用、多模态生成和1M令牌上下文窗口。',
+    displayName: 'Gemini 2.0 Flash 001',
+    id: 'gemini-2.0-flash-001',
+    maxOutput: 8192,
+    pricing: {
+      cachedInput: 0.025,
+      input: 0.1,
+      output: 0.4,
+    },
+    releasedAt: '2025-02-05',
+    type: 'chat',
+  },
+  {
+    abilities: {
+      vision: true,
+    },
+    contextWindowTokens: 1_048_576 + 8192,
+    description: '一个 Gemini 2.0 Flash 模型，针对成本效益和低延迟等目标进行了优化。',
+    displayName: 'Gemini 2.0 Flash-Lite Preview 02-05',
+    id: 'gemini-2.0-flash-lite-preview-02-05',
+    maxOutput: 8192,
+    pricing: {
+      cachedInput: 0.018_75,
+      input: 0.075,
+      output: 0.3,
+    },
+    releasedAt: '2025-02-05',
+    type: 'chat',
+  },
+  {
+    abilities: {
+      reasoning: true,
+      vision: true,
+    },
+    contextWindowTokens: 1_048_576 + 65_536,
+    description:
+      'Gemini 2.0 Flash Thinking Exp 是 Google 的实验性多模态推理AI模型，能对复杂问题进行推理，拥有新的思维能力。',
+    displayName: 'Gemini 2.0 Flash Thinking Experimental 01-21',
+    enabled: true,
+    id: 'gemini-2.0-flash-thinking-exp-01-21',
+    maxOutput: 65_536,
+    pricing: {
+      cachedInput: 0,
+      input: 0,
+      output: 0,
+    },
+    releasedAt: '2025-01-21',
+    type: 'chat',
+  },
+  {
+    abilities: { functionCall: true, vision: true },
+    contextWindowTokens: 1_000_000 + 8192,
+    description:
+      'Gemini 1.5 Flash 是Google最新的多模态AI模型，具备快速处理能力，支持文本、图像和视频输入，适用于多种任务的高效扩展。',
+    displayName: 'Gemini 1.5 Flash',
+    enabled: true,
+    id: 'gemini-1.5-flash',
+    maxOutput: 8192,
+    pricing: {
+      cachedInput: 0.018_75,
+      input: 0.075,
+      output: 0.3,
+    },
+    type: 'chat',
+  },
+  {
+    abilities: { functionCall: true, vision: true },
+    contextWindowTokens: 1_000_000 + 8192,
+    description: 'Gemini 1.5 Flash 002 是一款高效的多模态模型，支持广泛应用的扩展。',
+    displayName: 'Gemini 1.5 Flash 002',
+    enabled: true,
+    id: 'gemini-1.5-flash-002',
+    maxOutput: 8192,
+    pricing: {
+      cachedInput: 0.018_75,
+      input: 0.075,
+      output: 0.3,
+    },
+    releasedAt: '2024-09-25',
+    type: 'chat',
+  },
+  {
+    abilities: { functionCall: true, vision: true },
+    contextWindowTokens: 1_000_000 + 8192,
+    description: 'Gemini 1.5 Flash 001 是一款高效的多模态模型，支持广泛应用的扩展。',
+    displayName: 'Gemini 1.5 Flash 001',
+    id: 'gemini-1.5-flash-001',
+    maxOutput: 8192,
+    pricing: {
+      cachedInput: 0.018_75,
+      input: 0.075,
+      output: 0.3,
+    },
+    type: 'chat',
+  },
+  {
+    abilities: { functionCall: true, vision: true },
+    contextWindowTokens: 2_000_000 + 8192,
+    description:
+      'Gemini 1.5 Pro 支持高达200万个tokens，是中型多模态模型的理想选择，适用于复杂任务的多方面支持。',
+    displayName: 'Gemini 1.5 Pro',
+    enabled: true,
+    id: 'gemini-1.5-pro-latest',
+    maxOutput: 8192,
+    pricing: {
+      cachedInput: 0.875,
+      input: 3.5,
+      output: 10.5,
+    },
+    releasedAt: '2024-02-15',
+    type: 'chat',
+  },
+  {
+    abilities: { functionCall: true, vision: true },
+    contextWindowTokens: 2_000_000 + 8192,
+    description:
+      'Gemini 1.5 Pro 002 是最新的生产就绪模型，提供更高质量的输出，特别在数学、长上下文和视觉任务方面有显著提升。',
+    displayName: 'Gemini 1.5 Pro 002',
+    enabled: true,
+    id: 'gemini-1.5-pro-002',
+    maxOutput: 8192,
+    pricing: {
+      cachedInput: 0.315,
+      input: 1.25,
+      output: 2.5,
+    },
+    releasedAt: '2024-09-24',
+    type: 'chat',
+  },
+  {
+    abilities: { functionCall: true, vision: true },
+    contextWindowTokens: 2_000_000 + 8192,
+    description: 'Gemini 1.5 Pro 001 是可扩展的多模态AI解决方案，支持广泛的复杂任务。',
+    displayName: 'Gemini 1.5 Pro 001',
+    id: 'gemini-1.5-pro-001',
+    maxOutput: 8192,
+    pricing: {
+      cachedInput: 0.875,
+      input: 3.5,
+      output: 10.5,
+    },
+    releasedAt: '2024-02-15',
+    type: 'chat',
+  },
+];
+
+export const allModels = [...vertexaiChatModels];
+
+export default allModels;

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/libs/agent-runtime/error.ts

@@ -13,6 +13,7 @@ export const AgentRuntimeErrorType = {
   OllamaBizError: 'OllamaBizError',
 
   InvalidBedrockCredentials: 'InvalidBedrockCredentials',
+  InvalidVertexCredentials: 'InvalidVertexCredentials',
   StreamChunkError: 'StreamChunkError',
 
   InvalidGithubToken: 'InvalidGithubToken',

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/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

@@ -106,6 +106,7 @@ export default {
      */
     OpenAIBizError: '请求 OpenAI 服务出错，请根据以下信息排查或重试',
 
+    InvalidVertexCredentials: 'Vertex 鉴权未通过，请检查鉴权凭证后重试',
     InvalidBedrockCredentials: 'Bedrock 鉴权未通过，请检查 AccessKeyId/SecretAccessKey 后重试',
     StreamChunkError:
       '流式请求的消息块解析错误，请检查当前 API 接口是否符合标准规范，或联系你的 API 供应商咨询',