@ai-sdk/google-vertex 4.0.146 → 4.0.148

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

@@ -0,0 +1,46 @@
+import { z } from 'zod/v4';
+
+// Google Cloud Speech-to-Text transcription models (Speech-to-Text v2).
+// https://docs.cloud.google.com/speech-to-text/docs/transcription-model
+export type GoogleVertexTranscriptionModelId =
+  | 'chirp_2'
+  | 'chirp_3'
+  | 'telephony'
+  | (string & {});
+
+export const googleVertexTranscriptionProviderOptionsSchema = z.object({
+  /**
+   * BCP-47 language codes to recognize (e.g. `['en-US']`), or `['auto']` to let
+   * Chirp auto-detect the spoken language. Defaults to `['auto']`. For
+   * `telephony`, pass a supported explicit language code.
+   */
+  languageCodes: z.array(z.string()).optional(),
+
+  /**
+   * Whether to add punctuation to the transcript. Defaults to `true`.
+   */
+  enableAutomaticPunctuation: z.boolean().optional(),
+
+  /**
+   * Whether to include word-level timestamps. Defaults to `true` so the
+   * transcription result can include segments.
+   *
+   * Enabling word-level timestamps can reduce transcription quality and speed
+   * for Chirp models.
+   */
+  enableWordTimeOffsets: z.boolean().optional(),
+
+  /**
+   * The Cloud Speech-to-Text region for the request (e.g. `'us'`, `'eu'`,
+   * `'us-central1'`). Defaults to the provider `location`.
+   *
+   * Note: Speech-to-Text regions differ from Vertex AI regions. Chirp is only
+   * available in specific Speech-to-Text regions and is not available in the
+   * `global` location.
+   */
+  region: z.string().optional(),
+});
+
+export type GoogleVertexTranscriptionModelOptions = z.infer<
+  typeof googleVertexTranscriptionProviderOptionsSchema
+>;

package/src/google-vertex-transcription-model.ts

@@ -0,0 +1,214 @@
+import type { SharedV3Warning, TranscriptionModelV3 } from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler,
+  parseProviderOptions,
+  postJsonToApi,
+  resolve,
+  type FetchFunction,
+  type Resolvable,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { googleVertexFailedResponseHandler } from './google-vertex-error';
+import {
+  googleVertexTranscriptionProviderOptionsSchema,
+  type GoogleVertexTranscriptionModelId,
+  type GoogleVertexTranscriptionModelOptions,
+} from './google-vertex-transcription-model-options';
+
+interface GoogleVertexTranscriptionModelConfig {
+  provider: string;
+  /** Google Cloud project id. */
+  project: string;
+  /** Default Speech-to-Text region (overridable via provider options). */
+  location: string;
+  headers?: Resolvable<Record<string, string | undefined>>;
+  fetch?: FetchFunction;
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+// Speech-to-Text Durations are strings like `"1.200s"`; parse to seconds.
+function parseDurationSeconds(
+  value: string | null | undefined,
+): number | undefined {
+  if (value == null) {
+    return undefined;
+  }
+  const seconds = Number.parseFloat(value);
+  return Number.isFinite(seconds) ? seconds : undefined;
+}
+
+function convertBcp47ToIso6391(
+  value: string | null | undefined,
+): string | undefined {
+  if (value == null) {
+    return undefined;
+  }
+
+  try {
+    const language = new Intl.Locale(value).language;
+    return language.length === 2 ? language : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export class GoogleVertexTranscriptionModel implements TranscriptionModelV3 {
+  readonly specificationVersion = 'v3';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: GoogleVertexTranscriptionModelId,
+    private readonly config: GoogleVertexTranscriptionModelConfig,
+  ) {}
+
+  async doGenerate(
+    options: Parameters<TranscriptionModelV3['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<TranscriptionModelV3['doGenerate']>>> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const warnings: SharedV3Warning[] = [];
+
+    // Provider options may be passed under `googleVertex`, `vertex`, or `google`
+    // (matching the Vertex language + embedding models).
+    let googleOptions: GoogleVertexTranscriptionModelOptions | undefined;
+    for (const provider of ['googleVertex', 'vertex', 'google'] as const) {
+      googleOptions = await parseProviderOptions({
+        provider,
+        providerOptions: options.providerOptions,
+        schema: googleVertexTranscriptionProviderOptionsSchema,
+      });
+      if (googleOptions != null) {
+        break;
+      }
+    }
+
+    const region = googleOptions?.region ?? this.config.location;
+    const languageCodes = googleOptions?.languageCodes ?? ['auto'];
+
+    // The recognize API takes base64-encoded audio in the `content` field. A
+    // string audio input is already base64-encoded per the spec.
+    const content =
+      typeof options.audio === 'string'
+        ? options.audio
+        : convertUint8ArrayToBase64(options.audio);
+
+    const requestBody = {
+      config: {
+        model: this.modelId,
+        languageCodes,
+        // Let Speech-to-Text auto-detect the audio encoding (wav/mp3/flac/…).
+        autoDecodingConfig: {},
+        features: {
+          // Word timing populates `segments`.
+          enableWordTimeOffsets: googleOptions?.enableWordTimeOffsets ?? true,
+          enableAutomaticPunctuation:
+            googleOptions?.enableAutomaticPunctuation ?? true,
+        },
+      },
+      content,
+    };
+
+    const host =
+      region === 'global'
+        ? 'speech.googleapis.com'
+        : `${region}-speech.googleapis.com`;
+
+    const url =
+      `https://${host}/v2/projects/` +
+      `${this.config.project}/locations/${region}/recognizers/_:recognize`;
+
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse,
+    } = await postJsonToApi({
+      url,
+      headers: combineHeaders(
+        this.config.headers ? await resolve(this.config.headers) : undefined,
+        options.headers,
+      ),
+      body: requestBody,
+      failedResponseHandler: googleVertexFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        googleVertexTranscriptionResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    // Results are sequential portions of the audio; concatenate their primary
+    // alternatives into the full transcript and collect word-level segments.
+    const results = response.results ?? [];
+    const text = results
+      .map(result => result.alternatives?.[0]?.transcript ?? '')
+      .join(' ')
+      .trim();
+    const segments = results.flatMap(
+      result =>
+        result.alternatives?.[0]?.words?.flatMap(word => {
+          const startSecond = parseDurationSeconds(word.startOffset);
+          const endSecond = parseDurationSeconds(word.endOffset);
+
+          return word.word == null || startSecond == null || endSecond == null
+            ? []
+            : [{ text: word.word, startSecond, endSecond }];
+        }) ?? [],
+    );
+    const language = convertBcp47ToIso6391(results[0]?.languageCode);
+
+    return {
+      text,
+      segments,
+      language,
+      durationInSeconds: parseDurationSeconds(
+        response.metadata?.totalBilledDuration,
+      ),
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse,
+      },
+    };
+  }
+}
+
+// Minimal schema: only the fields the implementation reads, with `.nullish()`
+// so provider API changes don't break parsing.
+const googleVertexTranscriptionResponseSchema = z.object({
+  results: z
+    .array(
+      z.object({
+        alternatives: z
+          .array(
+            z.object({
+              transcript: z.string().nullish(),
+              words: z
+                .array(
+                  z.object({
+                    word: z.string().nullish(),
+                    startOffset: z.string().nullish(),
+                    endOffset: z.string().nullish(),
+                  }),
+                )
+                .nullish(),
+            }),
+          )
+          .nullish(),
+        languageCode: z.string().nullish(),
+      }),
+    )
+    .nullish(),
+  metadata: z
+    .object({
+      totalBilledDuration: z.string().nullish(),
+    })
+    .nullish(),
+});

package/src/index.ts

@@ -1,4 +1,8 @@
 export type { GoogleVertexEmbeddingModelOptions } from './google-vertex-embedding-options';
+export type {
+  GoogleVertexTranscriptionModelId,
+  GoogleVertexTranscriptionModelOptions,
+} from './google-vertex-transcription-model-options';
 export type {
   GoogleVertexImageModelOptions,
   /** @deprecated Use `GoogleVertexImageModelOptions` instead. */