@ai-sdk/google-vertex 5.0.49 → 5.0.50

package/src/google-vertex-cloud-tts-speech-model.ts

@@ -0,0 +1,188 @@
+import type { SharedV4Warning, SpeechModelV4 } from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler,
+  postJsonToApi,
+  resolve,
+  serializeModelOptions,
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE,
+  type FetchFunction,
+  type Resolvable,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { googleVertexFailedResponseHandler } from './google-vertex-error';
+import type { GoogleVertexSpeechModelId } from './google-vertex-speech-model-options';
+
+interface GoogleVertexCloudTTSSpeechModelConfig {
+  provider: string;
+  headers?: Resolvable<Record<string, string | undefined>>;
+  fetch?: FetchFunction;
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+const DEFAULT_VOICE = 'Kore';
+const DEFAULT_LANGUAGE = 'en-US';
+
+// Chirp 3: HD voice names are `<locale>-Chirp3-HD-<voice>`,
+// e.g. `en-US-Chirp3-HD-Kore`.
+// https://cloud.google.com/text-to-speech/docs/chirp3-hd
+const CHIRP3_HD_VOICE_INFIX = 'Chirp3-HD';
+
+// Cloud Text-to-Speech uses a single non-regional host for standard
+// synthesis (unlike Speech-to-Text and Vertex AI, which are regional).
+// https://cloud.google.com/text-to-speech/docs/reference/rest/v1/text/synthesize
+const CLOUD_TTS_SYNTHESIZE_URL =
+  'https://texttospeech.googleapis.com/v1/text:synthesize';
+
+/**
+ * Speech model for Chirp 3: HD voices on the Google Cloud Text-to-Speech API.
+ *
+ * Unlike the Gemini TTS models (which go through the Vertex
+ * `generateContent` endpoint via `GoogleSpeechModel`), Chirp 3: HD voices are
+ * served by the dedicated Cloud Text-to-Speech `text:synthesize` endpoint,
+ * reusing the provider's Google Cloud credentials.
+ */
+export class GoogleVertexCloudTTSSpeechModel implements SpeechModelV4 {
+  readonly specificationVersion = 'v4';
+
+  static [WORKFLOW_SERIALIZE](model: GoogleVertexCloudTTSSpeechModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: GoogleVertexSpeechModelId;
+    config: GoogleVertexCloudTTSSpeechModelConfig;
+  }) {
+    return new GoogleVertexCloudTTSSpeechModel(options.modelId, options.config);
+  }
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: GoogleVertexSpeechModelId,
+    private readonly config: GoogleVertexCloudTTSSpeechModelConfig,
+  ) {}
+
+  async doGenerate(
+    options: Parameters<SpeechModelV4['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<SpeechModelV4['doGenerate']>>> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const warnings: SharedV4Warning[] = [];
+
+    const {
+      text,
+      voice = DEFAULT_VOICE,
+      outputFormat,
+      instructions,
+      speed,
+      language,
+    } = options;
+
+    // Compose the voice name. A fully-qualified Chirp 3: HD voice name
+    // (e.g. `en-US-Chirp3-HD-Kore`) is passed through verbatim, with its
+    // locale prefix as the language code; otherwise the name is composed
+    // from the language (BCP-47 locale, e.g. `en-US`) and the plain voice
+    // name (e.g. `Kore`).
+    let voiceName: string;
+    let languageCode: string;
+    if (voice.includes(CHIRP3_HD_VOICE_INFIX)) {
+      voiceName = voice;
+      // The locale prefix may be missing (e.g. `Chirp3-HD-Kore`), in which
+      // case the extracted prefix is empty and the default language is used.
+      const localePrefix = voice
+        .split(CHIRP3_HD_VOICE_INFIX)[0]
+        .replace(/-$/, '');
+      languageCode = language ?? (localePrefix || DEFAULT_LANGUAGE);
+    } else {
+      languageCode = language ?? DEFAULT_LANGUAGE;
+      voiceName = `${languageCode}-${CHIRP3_HD_VOICE_INFIX}-${voice}`;
+    }
+
+    if (instructions != null) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'instructions',
+        details:
+          'Google Cloud Text-to-Speech Chirp 3: HD voices do not support the `instructions` option. It was ignored.',
+      });
+    }
+
+    // LINEAR16 responses are WAV (RIFF) files, so only `wav` is supported.
+    if (outputFormat != null && outputFormat !== 'wav') {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'outputFormat',
+        details: `Unsupported output format: ${outputFormat}. Using wav instead.`,
+      });
+    }
+
+    const requestBody = {
+      input: { text },
+      voice: { languageCode, name: voiceName },
+      audioConfig: {
+        audioEncoding: 'LINEAR16',
+        ...(speed != null ? { speakingRate: speed } : {}),
+      },
+    };
+
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse,
+    } = await postJsonToApi({
+      url: CLOUD_TTS_SYNTHESIZE_URL,
+      headers: combineHeaders(
+        this.config.headers ? await resolve(this.config.headers) : undefined,
+        options.headers,
+      ),
+      body: requestBody,
+      failedResponseHandler: googleVertexFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        googleVertexCloudTTSResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    // Empty audio is returned as-is so the core layer throws
+    // NoSpeechGeneratedError.
+    const audio =
+      response.audioContent != null
+        ? convertBase64ToUint8Array(response.audioContent)
+        : new Uint8Array(0);
+
+    return {
+      audio,
+      warnings,
+      request: {
+        body: JSON.stringify(requestBody),
+      },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse,
+      },
+      providerMetadata: {
+        google: {
+          mimeType: 'audio/wav',
+        },
+      },
+    };
+  }
+}
+
+// Minimal schema: only the fields the implementation reads, with `.nullish()`
+// so provider API changes don't break parsing.
+const googleVertexCloudTTSResponseSchema = z.object({
+  audioContent: z.string().nullish(),
+});

package/src/google-vertex-provider-base.ts

@@ -32,6 +32,7 @@ import type { GoogleVertexEmbeddingModelId } from './google-vertex-embedding-mod
 import { GoogleVertexImageModel } from './google-vertex-image-model';
 import type { GoogleVertexImageModelId } from './google-vertex-image-settings';
 import type { GoogleVertexModelId } from './google-vertex-options';
+import { GoogleVertexCloudTTSSpeechModel } from './google-vertex-cloud-tts-speech-model';
 import { googleVertexTools } from './google-vertex-tools';
 import { GoogleVertexTranscriptionModel } from './google-vertex-transcription-model';
 import type { GoogleVertexTranscriptionModelId } from './google-vertex-transcription-model-options';
@@ -327,8 +328,24 @@ export function createGoogleVertex(
       generateId: options.generateId ?? generateId,
     });
 
-  const createSpeechModel = (modelId: GoogleVertexSpeechModelId) =>
-    new GoogleSpeechModel(modelId, createConfig('speech'));
+  const createSpeechModel = (modelId: GoogleVertexSpeechModelId) => {
+    if (modelId.startsWith('chirp')) {
+      if (apiKey) {
+        throw new Error(
+          'Google Vertex Chirp speech models do not support Express Mode API keys. Use standard Google Cloud credentials instead.',
+        );
+      }
+
+      const config = createConfig('speech');
+      return new GoogleVertexCloudTTSSpeechModel(modelId, {
+        provider: config.provider,
+        headers: config.headers,
+        fetch: config.fetch,
+      });
+    }
+
+    return new GoogleSpeechModel(modelId, createConfig('speech'));
+  };
 
   // Cloud Speech-to-Text reuses the Vertex auth headers from createConfig, but
   // targets the Speech-to-Text API.

package/src/google-vertex-speech-model-options.ts

@@ -1,11 +1,15 @@
 import type { GoogleSpeechModelOptions } from '@ai-sdk/google';
 
+// Gemini TTS models (Vertex `generateContent` endpoint):
 // https://docs.cloud.google.com/text-to-speech/docs/gemini-tts
+// Chirp 3: HD voices (Cloud Text-to-Speech `text:synthesize` endpoint):
+// https://docs.cloud.google.com/text-to-speech/docs/chirp3-hd
 export type GoogleVertexSpeechModelId =
   | 'gemini-2.5-flash-tts'
   | 'gemini-2.5-pro-tts'
   | 'gemini-2.5-flash-lite-preview-tts'
   | 'gemini-3.1-flash-tts-preview'
+  | 'chirp-3-hd'
   | (string & {});
 
 export type GoogleVertexSpeechModelOptions = GoogleSpeechModelOptions;