@ai-sdk/google-vertex 5.0.0-beta.11 → 5.0.0-beta.112

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

@@ -0,0 +1,231 @@
+import type { SharedV4Warning, TranscriptionModelV4 } from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler,
+  parseProviderOptions,
+  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 {
+  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 TranscriptionModelV4 {
+  readonly specificationVersion = 'v4';
+
+  static [WORKFLOW_SERIALIZE](model: GoogleVertexTranscriptionModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: GoogleVertexTranscriptionModelId;
+    config: GoogleVertexTranscriptionModelConfig;
+  }) {
+    return new GoogleVertexTranscriptionModel(options.modelId, options.config);
+  }
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: GoogleVertexTranscriptionModelId,
+    private readonly config: GoogleVertexTranscriptionModelConfig,
+  ) {}
+
+  async doGenerate(
+    options: Parameters<TranscriptionModelV4['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<TranscriptionModelV4['doGenerate']>>> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const warnings: SharedV4Warning[] = [];
+
+    // 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/google-vertex-video-model-options.ts

@@ -0,0 +1,49 @@
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export type GoogleVertexVideoModelOptions = {
+  // Polling configuration
+  pollIntervalMs?: number | null;
+  pollTimeoutMs?: number | null;
+
+  // Video generation options
+  personGeneration?: 'dont_allow' | 'allow_adult' | 'allow_all' | null;
+  negativePrompt?: string | null;
+  generateAudio?: boolean | null;
+
+  // Output configuration
+  gcsOutputDirectory?: string | null;
+
+  // Reference images (for style/asset reference)
+  referenceImages?: Array<{
+    bytesBase64Encoded?: string;
+    gcsUri?: string;
+  }> | null;
+
+  [key: string]: unknown; // For passthrough
+};
+
+export const googleVertexVideoModelOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        pollIntervalMs: z.number().positive().nullish(),
+        pollTimeoutMs: z.number().positive().nullish(),
+        personGeneration: z
+          .enum(['dont_allow', 'allow_adult', 'allow_all'])
+          .nullish(),
+        negativePrompt: z.string().nullish(),
+        generateAudio: z.boolean().nullish(),
+        gcsOutputDirectory: z.string().nullish(),
+        referenceImages: z
+          .array(
+            z.object({
+              bytesBase64Encoded: z.string().nullish(),
+              gcsUri: z.string().nullish(),
+            }),
+          )
+          .nullish(),
+      })
+      .passthrough(),
+  ),
+);

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

@@ -8,40 +8,20 @@ import {
   convertUint8ArrayToBase64,
   createJsonResponseHandler,
   delay,
-  type FetchFunction,
-  lazySchema,
   parseProviderOptions,
   postJsonToApi,
-  type Resolvable,
   resolve,
-  zodSchema,
+  type FetchFunction,
+  type Resolvable,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { googleVertexFailedResponseHandler } from './google-vertex-error';
+import {
+  googleVertexVideoModelOptionsSchema,
+  type GoogleVertexVideoModelOptions,
+} from './google-vertex-video-model-options';
 import type { GoogleVertexVideoModelId } from './google-vertex-video-settings';
 
-export type GoogleVertexVideoModelOptions = {
-  // Polling configuration
-  pollIntervalMs?: number | null;
-  pollTimeoutMs?: number | null;
-
-  // Video generation options
-  personGeneration?: 'dont_allow' | 'allow_adult' | 'allow_all' | null;
-  negativePrompt?: string | null;
-  generateAudio?: boolean | null;
-
-  // Output configuration
-  gcsOutputDirectory?: string | null;
-
-  // Reference images (for style/asset reference)
-  referenceImages?: Array<{
-    bytesBase64Encoded?: string;
-    gcsUri?: string;
-  }> | null;
-
-  [key: string]: unknown; // For passthrough
-};
-
 interface GoogleVertexVideoModelConfig {
   provider: string;
   baseURL: string;
@@ -76,11 +56,16 @@ export class GoogleVertexVideoModel implements Experimental_VideoModelV4 {
     const currentDate = this.config._internal?.currentDate?.() ?? new Date();
     const warnings: SharedV4Warning[] = [];
 
-    const vertexOptions = (await parseProviderOptions({
-      provider: 'vertex',
+    const googleVertexOptions = ((await parseProviderOptions({
+      provider: 'googleVertex',
       providerOptions: options.providerOptions,
       schema: googleVertexVideoModelOptionsSchema,
-    })) as GoogleVertexVideoModelOptions | undefined;
+    })) ??
+      (await parseProviderOptions({
+        provider: 'vertex',
+        providerOptions: options.providerOptions,
+        schema: googleVertexVideoModelOptionsSchema,
+      }))) as GoogleVertexVideoModelOptions | undefined;
 
     const instances: Array<Record<string, unknown>> = [{}];
     const instance = instances[0];
@@ -110,8 +95,8 @@ export class GoogleVertexVideoModel implements Experimental_VideoModelV4 {
       }
     }
 
-    if (vertexOptions?.referenceImages != null) {
-      instance.referenceImages = vertexOptions.referenceImages;
+    if (googleVertexOptions?.referenceImages != null) {
+      instance.referenceImages = googleVertexOptions.referenceImages;
     }
 
     const parameters: Record<string, unknown> = {
@@ -140,8 +125,14 @@ export class GoogleVertexVideoModel implements Experimental_VideoModelV4 {
       parameters.seed = options.seed;
     }
 
-    if (vertexOptions != null) {
-      const opts = vertexOptions;
+    const generateAudio =
+      options.generateAudio ?? googleVertexOptions?.generateAudio;
+    if (generateAudio != null) {
+      parameters.generateAudio = generateAudio;
+    }
+
+    if (googleVertexOptions != null) {
+      const opts = googleVertexOptions;
 
       if (
         opts.personGeneration !== undefined &&
@@ -152,9 +143,6 @@ export class GoogleVertexVideoModel implements Experimental_VideoModelV4 {
       if (opts.negativePrompt !== undefined && opts.negativePrompt !== null) {
         parameters.negativePrompt = opts.negativePrompt;
       }
-      if (opts.generateAudio !== undefined && opts.generateAudio !== null) {
-        parameters.generateAudio = opts.generateAudio;
-      }
       if (
         opts.gcsOutputDirectory !== undefined &&
         opts.gcsOutputDirectory !== null
@@ -190,7 +178,7 @@ export class GoogleVertexVideoModel implements Experimental_VideoModelV4 {
         parameters,
       },
       successfulResponseHandler: createJsonResponseHandler(
-        vertexOperationSchema,
+        googleVertexOperationSchema,
       ),
       failedResponseHandler: googleVertexFailedResponseHandler,
       abortSignal: options.abortSignal,
@@ -205,8 +193,8 @@ export class GoogleVertexVideoModel implements Experimental_VideoModelV4 {
       });
     }
 
-    const pollIntervalMs = vertexOptions?.pollIntervalMs ?? 10000; // 10 seconds
-    const pollTimeoutMs = vertexOptions?.pollTimeoutMs ?? 600000; // 10 minutes
+    const pollIntervalMs = googleVertexOptions?.pollIntervalMs ?? 10000; // 10 seconds
+    const pollTimeoutMs = googleVertexOptions?.pollTimeoutMs ?? 600000; // 10 minutes
 
     const startTime = Date.now();
     let finalOperation = operation;
@@ -240,7 +228,7 @@ export class GoogleVertexVideoModel implements Experimental_VideoModelV4 {
             operationName,
           },
           successfulResponseHandler: createJsonResponseHandler(
-            vertexOperationSchema,
+            googleVertexOperationSchema,
           ),
           failedResponseHandler: googleVertexFailedResponseHandler,
           abortSignal: options.abortSignal,
@@ -314,16 +302,20 @@ export class GoogleVertexVideoModel implements Experimental_VideoModelV4 {
         modelId: this.modelId,
         headers: responseHeaders,
       },
-      providerMetadata: {
-        'google-vertex': {
-          videos: videoMetadata,
-        },
-      },
+      providerMetadata: (() => {
+        const payload = { videos: videoMetadata };
+        return {
+          googleVertex: payload,
+          // Legacy keys preserved for backward compatibility.
+          'google-vertex': payload,
+          vertex: payload,
+        };
+      })(),
     };
   }
 }
 
-const vertexOperationSchema = z.object({
+const googleVertexOperationSchema = z.object({
   name: z.string().nullish(),
   done: z.boolean().nullish(),
   error: z
@@ -348,28 +340,3 @@ const vertexOperationSchema = z.object({
     })
     .nullish(),
 });
-
-const googleVertexVideoModelOptionsSchema = lazySchema(() =>
-  zodSchema(
-    z
-      .object({
-        pollIntervalMs: z.number().positive().nullish(),
-        pollTimeoutMs: z.number().positive().nullish(),
-        personGeneration: z
-          .enum(['dont_allow', 'allow_adult', 'allow_all'])
-          .nullish(),
-        negativePrompt: z.string().nullish(),
-        generateAudio: z.boolean().nullish(),
-        gcsOutputDirectory: z.string().nullish(),
-        referenceImages: z
-          .array(
-            z.object({
-              bytesBase64Encoded: z.string().nullish(),
-              gcsUri: z.string().nullish(),
-            }),
-          )
-          .nullish(),
-      })
-      .passthrough(),
-  ),
-);

package/src/index.ts

@@ -1,18 +1,33 @@
-export type { GoogleVertexEmbeddingModelOptions } from './google-vertex-embedding-options';
+export type { GoogleVertexEmbeddingModelOptions } from './google-vertex-embedding-model-options';
+export type {
+  GoogleVertexTranscriptionModelId,
+  GoogleVertexTranscriptionModelOptions,
+} from './google-vertex-transcription-model-options';
 export type {
   GoogleVertexImageModelOptions,
   /** @deprecated Use `GoogleVertexImageModelOptions` instead. */
   GoogleVertexImageModelOptions as GoogleVertexImageProviderOptions,
-} from './google-vertex-image-model';
+} from './google-vertex-image-model-options';
 export type {
   GoogleVertexVideoModelOptions,
   /** @deprecated Use `GoogleVertexVideoModelOptions` instead. */
   GoogleVertexVideoModelOptions as GoogleVertexVideoProviderOptions,
-} from './google-vertex-video-model';
+} from './google-vertex-video-model-options';
 export type { GoogleVertexVideoModelId } from './google-vertex-video-settings';
-export { createVertex, vertex } from './google-vertex-provider-node';
+export type {
+  GoogleVertexSpeechModelId,
+  GoogleVertexSpeechModelOptions,
+} from './google-vertex-speech-model-options';
+export {
+  createGoogleVertex,
+  /** @deprecated Use `createGoogleVertex` instead. */
+  createGoogleVertex as createVertex,
+  googleVertex,
+  /** @deprecated Use `googleVertex` instead. */
+  googleVertex as vertex,
+} from './google-vertex-provider';
 export type {
   GoogleVertexProvider,
   GoogleVertexProviderSettings,
-} from './google-vertex-provider-node';
+} from './google-vertex-provider';
 export { VERSION } from './version';

package/src/maas/edge/google-vertex-maas-provider-edge.ts

@@ -0,0 +1,64 @@
+import { resolve, type FetchFunction } from '@ai-sdk/provider-utils';
+import {
+  generateAuthToken,
+  type GoogleCredentials,
+} from '../../edge/google-vertex-auth-edge';
+import {
+  createGoogleVertexMaas as createVertexMaasOriginal,
+  type GoogleVertexMaasProvider,
+  type GoogleVertexMaasProviderSettings as GoogleVertexMaasProviderSettingsOriginal,
+} from '../google-vertex-maas-provider';
+export type { GoogleVertexMaasProvider };
+
+export interface GoogleVertexMaasProviderSettings extends GoogleVertexMaasProviderSettingsOriginal {
+  /**
+   * Optional. The Google credentials for the Google Cloud service account. If
+   * not provided, the Google Vertex provider will use environment variables to
+   * load the credentials.
+   */
+  googleCredentials?: GoogleCredentials;
+}
+
+/**
+ * Create a Google Vertex AI MaaS (Model as a Service) provider instance for Edge runtimes.
+ * Uses the OpenAI-compatible Chat Completions API for partner and open models.
+ * Automatically handles Google Cloud authentication.
+ *
+ * @see https://cloud.google.com/vertex-ai/generative-ai/docs/maas/use-open-models
+ */
+export function createGoogleVertexMaas(
+  options: GoogleVertexMaasProviderSettings = {},
+): GoogleVertexMaasProvider {
+  // Create a custom fetch wrapper that adds auth headers
+  const customFetch: FetchFunction = async (url, init) => {
+    const token = await generateAuthToken(options.googleCredentials);
+    const resolvedHeaders = await resolve(options.headers);
+    const authHeaders = {
+      ...resolvedHeaders,
+      Authorization: `Bearer ${token}`,
+    };
+
+    // Merge auth headers with existing headers from init
+    const fetchInit = {
+      ...init,
+      headers: {
+        ...init?.headers,
+        ...authHeaders,
+      },
+    };
+
+    // Call the original fetch or user's custom fetch
+    return (options.fetch ?? fetch)(url, fetchInit);
+  };
+
+  return createVertexMaasOriginal({
+    ...options,
+    fetch: customFetch,
+    headers: undefined, // Don't pass headers, we handle them in fetch
+  });
+}
+
+/**
+ * Default Google Vertex AI MaaS provider instance for Edge runtimes.
+ */
+export const googleVertexMaas = createGoogleVertexMaas();

package/src/maas/edge/index.ts

@@ -0,0 +1,13 @@
+export {
+  createGoogleVertexMaas,
+  /** @deprecated Use `createGoogleVertexMaas` instead. */
+  createGoogleVertexMaas as createVertexMaas,
+  googleVertexMaas,
+  /** @deprecated Use `googleVertexMaas` instead. */
+  googleVertexMaas as vertexMaas,
+} from './google-vertex-maas-provider-edge';
+export type {
+  GoogleVertexMaasProvider,
+  GoogleVertexMaasProviderSettings,
+} from './google-vertex-maas-provider-edge';
+export type { GoogleVertexMaasModelId } from '../google-vertex-maas-options';

package/src/maas/google-vertex-maas-options.ts

@@ -0,0 +1,15 @@
+// https://cloud.google.com/vertex-ai/generative-ai/docs/maas/use-open-models
+export type GoogleVertexMaasModelId =
+  | 'deepseek-ai/deepseek-r1-0528-maas'
+  | 'deepseek-ai/deepseek-v3.1-maas'
+  | 'deepseek-ai/deepseek-v3.2-maas'
+  | 'openai/gpt-oss-120b-maas'
+  | 'openai/gpt-oss-20b-maas'
+  | 'meta/llama-4-maverick-17b-128e-instruct-maas'
+  | 'meta/llama-4-scout-17b-16e-instruct-maas'
+  | 'minimax/minimax-m2-maas'
+  | 'qwen/qwen3-coder-480b-a35b-instruct-maas'
+  | 'qwen/qwen3-next-80b-a3b-instruct-maas'
+  | 'qwen/qwen3-next-80b-a3b-thinking-maas'
+  | 'moonshotai/kimi-k2-thinking-maas'
+  | (string & {});

package/src/maas/google-vertex-maas-provider-node.ts

@@ -0,0 +1,65 @@
+import { resolve, type FetchFunction } from '@ai-sdk/provider-utils';
+import type { GoogleAuthOptions } from 'google-auth-library';
+import { createAuthTokenGenerator } from '../google-vertex-auth-google-auth-library';
+import {
+  createGoogleVertexMaas as createVertexMaasOriginal,
+  type GoogleVertexMaasProvider,
+  type GoogleVertexMaasProviderSettings as GoogleVertexMaasProviderSettingsOriginal,
+} from './google-vertex-maas-provider';
+export type { GoogleVertexMaasProvider };
+
+export interface GoogleVertexMaasProviderSettings extends GoogleVertexMaasProviderSettingsOriginal {
+  /**
+   * Optional. The Authentication options provided by google-auth-library.
+   * Complete list of authentication options is documented in the
+   * GoogleAuthOptions interface:
+   * https://github.com/googleapis/google-auth-library-nodejs/blob/main/src/auth/googleauth.ts.
+   */
+  googleAuthOptions?: GoogleAuthOptions;
+}
+
+/**
+ * Create a Google Vertex AI MaaS (Model as a Service) provider instance for Node.js.
+ * Uses the OpenAI-compatible Chat Completions API for partner and open models.
+ * Automatically handles Google Cloud authentication.
+ *
+ * @see https://cloud.google.com/vertex-ai/generative-ai/docs/maas/use-open-models
+ */
+export function createGoogleVertexMaas(
+  options: GoogleVertexMaasProviderSettings = {},
+): GoogleVertexMaasProvider {
+  const generateAuthToken = createAuthTokenGenerator(options.googleAuthOptions);
+
+  // Create a custom fetch wrapper that adds auth headers
+  const customFetch: FetchFunction = async (url, init) => {
+    const token = await generateAuthToken();
+    const resolvedHeaders = await resolve(options.headers);
+    const authHeaders = {
+      ...resolvedHeaders,
+      Authorization: `Bearer ${token}`,
+    };
+
+    // Merge auth headers with existing headers from init
+    const fetchInit = {
+      ...init,
+      headers: {
+        ...init?.headers,
+        ...authHeaders,
+      },
+    };
+
+    // Call the original fetch or user's custom fetch
+    return (options.fetch ?? fetch)(url, fetchInit);
+  };
+
+  return createVertexMaasOriginal({
+    ...options,
+    fetch: customFetch,
+    headers: undefined, // Don't pass headers, we handle them in fetch
+  });
+}
+
+/**
+ * Default Google Vertex AI MaaS provider instance for Node.js.
+ */
+export const googleVertexMaas = createGoogleVertexMaas();