@ai-sdk/google-vertex 4.0.189 → 4.0.193

package/dist/index.mjs

@@ -1,5 +1,235 @@
+// src/gemini-transcription/google-vertex-gemini-transcription-model.ts
+import {
+  InvalidArgumentError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  convertToBase64,
+  createJsonResponseHandler,
+  parseProviderOptions,
+  postJsonToApi,
+  resolve
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
+
+// src/google-vertex-error.ts
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var googleVertexErrorDataSchema = z.object({
+  error: z.object({
+    code: z.number().nullable(),
+    message: z.string(),
+    status: z.string()
+  })
+});
+var googleVertexFailedResponseHandler = createJsonErrorResponseHandler(
+  {
+    errorSchema: googleVertexErrorDataSchema,
+    errorToMessage: (data) => data.error.message
+  }
+);
+
+// src/gemini-transcription/google-vertex-gemini-transcription-model-options.ts
+import { z as z2 } from "zod/v4";
+var googleVertexGeminiTranscriptionModelOptions = z2.object({
+  /**
+   * BCP-47 language codes providing hints about the languages present in the
+   * audio. If omitted or empty, defaults to automatic language detection.
+   */
+  languageCodes: z2.array(z2.string()).optional(),
+  /**
+   * Custom vocabulary phrases, which bias the speech recognition model
+   * toward recognizing specific terms.
+   */
+  customVocabulary: z2.array(z2.string()).optional(),
+  /**
+   * Enables word-level timestamp generation.
+   */
+  wordTimestamp: z2.boolean().optional(),
+  /**
+   * Enables speaker diarization.
+   */
+  diarization: z2.boolean().optional(),
+  /**
+   * Transcription output formatting mode.
+   *
+   * - `VERBATIM` (default): exact literal transcript preserving filler
+   *   words, repetitions, and false starts.
+   * - `SMART`: cleans up and structures the transcript in real time —
+   *   disfluency removal, inline self-corrections, structured formatting
+   *   (lists, numbers, dates, paragraph breaks), and grammar/casing polish.
+   */
+  mode: z2.enum(["SMART", "VERBATIM"]).optional()
+});
+
+// src/gemini-transcription/google-vertex-gemini-transcription-model.ts
+function isLiveTranscriptionModelId(modelId) {
+  return modelId.includes("-live");
+}
+var GoogleVertexGeminiTranscriptionModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async parseOptions(providerOptions) {
+    for (const provider of ["googleVertex", "vertex", "google"]) {
+      const parsed = await parseProviderOptions({
+        provider,
+        providerOptions,
+        schema: googleVertexGeminiTranscriptionModelOptions
+      });
+      if (parsed != null) return parsed;
+    }
+    return void 0;
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    if (isLiveTranscriptionModelId(this.modelId)) {
+      throw new InvalidArgumentError({
+        argument: "modelId",
+        message: `Model '${this.modelId}' only supports streaming transcription, which requires AI SDK v7. Use a unary model such as 'gemini-3.5-transcribe'.`
+      });
+    }
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const warnings = [];
+    const googleOptions = await this.parseOptions(options.providerOptions);
+    const audioTranscriptionConfig = buildAudioTranscriptionConfig(googleOptions);
+    const requestBody = {
+      contents: [
+        {
+          role: "user",
+          parts: [
+            {
+              inlineData: {
+                mimeType: options.mediaType,
+                data: convertToBase64(options.audio)
+              }
+            }
+          ]
+        }
+      ],
+      ...audioTranscriptionConfig != null ? { generationConfig: { audioTranscriptionConfig } } : {}
+    };
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: `${this.config.baseURL}/models/${this.modelId}:generateContent`,
+      headers: combineHeaders(
+        this.config.headers ? await resolve(this.config.headers) : void 0,
+        options.headers
+      ),
+      body: requestBody,
+      failedResponseHandler: googleVertexFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        googleVertexGeminiTranscriptionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const parts = (_g = (_f = (_e = (_d = response.candidates) == null ? void 0 : _d[0]) == null ? void 0 : _e.content) == null ? void 0 : _f.parts) != null ? _g : [];
+    const plainText = parts.map((part) => {
+      var _a2;
+      return (_a2 = part.text) != null ? _a2 : "";
+    }).join("");
+    const transcriptionText = parts.map((part) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = part.audioTranscription) == null ? void 0 : _a2.text) != null ? _b2 : "";
+    }).join("");
+    const text = plainText !== "" ? plainText : transcriptionText;
+    let language;
+    const segments = [];
+    for (const part of parts) {
+      const transcription = part.audioTranscription;
+      if (transcription == null) continue;
+      language != null ? language : language = (_h = transcription.languageCode) != null ? _h : void 0;
+      for (const word of (_i = transcription.words) != null ? _i : []) {
+        const startSecond = parseOffsetSeconds(word.startOffset);
+        const endSecond = parseOffsetSeconds(word.endOffset);
+        if (word.word == null || startSecond == null || endSecond == null) {
+          continue;
+        }
+        segments.push({ text: word.word, startSecond, endSecond });
+      }
+    }
+    return {
+      text,
+      segments,
+      language,
+      durationInSeconds: void 0,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      ...response.usageMetadata != null ? {
+        providerMetadata: {
+          google: { usageMetadata: response.usageMetadata }
+        }
+      } : {}
+    };
+  }
+};
+function buildAudioTranscriptionConfig(options) {
+  if (options == null) return void 0;
+  const config = {};
+  if (options.languageCodes != null) {
+    config.languageCodes = options.languageCodes;
+  }
+  if (options.customVocabulary != null) {
+    config.customVocabulary = options.customVocabulary;
+  }
+  if (options.wordTimestamp != null) {
+    config.wordTimestamp = options.wordTimestamp;
+  }
+  if (options.diarization != null) {
+    config.diarization = options.diarization;
+  }
+  if (options.mode != null) {
+    config.mode = options.mode;
+  }
+  return Object.keys(config).length > 0 ? config : void 0;
+}
+function parseOffsetSeconds(offset) {
+  if (offset == null) return void 0;
+  const parsed = Number.parseFloat(offset);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+var googleVertexGeminiTranscriptionWordSchema = z3.object({
+  word: z3.string().nullish(),
+  startOffset: z3.string().nullish(),
+  endOffset: z3.string().nullish()
+});
+var googleVertexGeminiTranscriptionResponseSchema = z3.object({
+  candidates: z3.array(
+    z3.object({
+      content: z3.object({
+        parts: z3.array(
+          z3.object({
+            text: z3.string().nullish(),
+            audioTranscription: z3.object({
+              text: z3.string().nullish(),
+              languageCode: z3.string().nullish(),
+              speakerLabel: z3.string().nullish(),
+              words: z3.array(googleVertexGeminiTranscriptionWordSchema).nullish()
+            }).nullish()
+          })
+        ).nullish()
+      }).nullish()
+    })
+  ).nullish(),
+  usageMetadata: z3.record(z3.string(), z3.unknown()).nullish()
+});
+
 // src/google-vertex-provider-node.ts
-import { loadOptionalSetting as loadOptionalSetting2, resolve as resolve6 } from "@ai-sdk/provider-utils";
+import { loadOptionalSetting as loadOptionalSetting2, resolve as resolve7 } from "@ai-sdk/provider-utils";
 
 // src/google-vertex-auth-google-auth-library.ts
 import { GoogleAuth } from "google-auth-library";
@@ -26,52 +256,35 @@ import {
   loadOptionalSetting,
   loadSetting,
   normalizeHeaders,
-  resolve as resolve5,
+  resolve as resolve6,
   withoutTrailingSlash,
   withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "4.0.189" : "0.0.0-test";
+var VERSION = true ? "4.0.193" : "0.0.0-test";
 
 // src/google-vertex-embedding-model.ts
 import {
   TooManyEmbeddingValuesForCallError
 } from "@ai-sdk/provider";
 import {
-  combineHeaders,
-  createJsonResponseHandler,
-  postJsonToApi,
-  resolve,
-  parseProviderOptions
+  combineHeaders as combineHeaders2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  postJsonToApi as postJsonToApi2,
+  resolve as resolve2,
+  parseProviderOptions as parseProviderOptions2
 } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
-
-// src/google-vertex-error.ts
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
-var googleVertexErrorDataSchema = z.object({
-  error: z.object({
-    code: z.number().nullable(),
-    message: z.string(),
-    status: z.string()
-  })
-});
-var googleVertexFailedResponseHandler = createJsonErrorResponseHandler(
-  {
-    errorSchema: googleVertexErrorDataSchema,
-    errorToMessage: (data) => data.error.message
-  }
-);
+import { z as z5 } from "zod/v4";
 
 // src/google-vertex-embedding-options.ts
-import { z as z2 } from "zod/v4";
-var googleVertexEmbeddingModelOptions = z2.object({
+import { z as z4 } from "zod/v4";
+var googleVertexEmbeddingModelOptions = z4.object({
   /**
    * Optional. Optional reduced dimension for the output embedding.
    * If set, excessive values in the output embedding are truncated from the end.
    */
-  outputDimensionality: z2.number().optional(),
+  outputDimensionality: z4.number().optional(),
   /**
    * Optional. Specifies the task type for generating embeddings.
    * Supported task types:
@@ -84,7 +297,7 @@ var googleVertexEmbeddingModelOptions = z2.object({
    * - FACT_VERIFICATION: Optimized for verifying factual information.
    * - CODE_RETRIEVAL_QUERY: Optimized for retrieving code blocks based on natural language queries.
    */
-  taskType: z2.enum([
+  taskType: z4.enum([
     "SEMANTIC_SIMILARITY",
     "CLASSIFICATION",
     "CLUSTERING",
@@ -99,12 +312,12 @@ var googleVertexEmbeddingModelOptions = z2.object({
    * Only valid when task_type is set to 'RETRIEVAL_DOCUMENT'.
    * Helps the model produce better embeddings by providing additional context.
    */
-  title: z2.string().optional(),
+  title: z4.string().optional(),
   /**
    * Optional. When set to true, input text will be truncated. When set to false,
    * an error is returned if the input text is longer than the maximum length supported by the model. Defaults to true.
    */
-  autoTruncate: z2.boolean().optional()
+  autoTruncate: z4.boolean().optional()
 });
 
 // src/google-vertex-embedding-model.ts
@@ -130,13 +343,13 @@ var GoogleVertexEmbeddingModel = class {
     providerOptions
   }) {
     var _a;
-    let googleOptions = await parseProviderOptions({
+    let googleOptions = await parseProviderOptions2({
       provider: "vertex",
       providerOptions,
       schema: googleVertexEmbeddingModelOptions
     });
     if (googleOptions == null) {
-      googleOptions = await parseProviderOptions({
+      googleOptions = await parseProviderOptions2({
         provider: "google",
         providerOptions,
         schema: googleVertexEmbeddingModelOptions
@@ -151,8 +364,8 @@ var GoogleVertexEmbeddingModel = class {
         values
       });
     }
-    const mergedHeaders = combineHeaders(
-      await resolve(this.config.headers),
+    const mergedHeaders = combineHeaders2(
+      await resolve2(this.config.headers),
       headers
     );
     if (usesEmbedContentEndpoint(this.modelId)) {
@@ -160,7 +373,7 @@ var GoogleVertexEmbeddingModel = class {
         responseHeaders: responseHeaders2,
         value: response2,
         rawValue: rawValue2
-      } = await postJsonToApi({
+      } = await postJsonToApi2({
         url: `${this.config.baseURL}/models/${this.modelId}:embedContent`,
         headers: mergedHeaders,
         body: {
@@ -173,7 +386,7 @@ var GoogleVertexEmbeddingModel = class {
           }
         },
         failedResponseHandler: googleVertexFailedResponseHandler,
-        successfulResponseHandler: createJsonResponseHandler(
+        successfulResponseHandler: createJsonResponseHandler2(
           googleVertexEmbedContentResponseSchema
         ),
         abortSignal,
@@ -191,7 +404,7 @@ var GoogleVertexEmbeddingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await postJsonToApi({
+    } = await postJsonToApi2({
       url,
       headers: mergedHeaders,
       body: {
@@ -206,7 +419,7 @@ var GoogleVertexEmbeddingModel = class {
         }
       },
       failedResponseHandler: googleVertexFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
+      successfulResponseHandler: createJsonResponseHandler2(
         googleVertexTextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -227,24 +440,24 @@ var GoogleVertexEmbeddingModel = class {
     };
   }
 };
-var googleVertexTextEmbeddingResponseSchema = z3.object({
-  predictions: z3.array(
-    z3.object({
-      embeddings: z3.object({
-        values: z3.array(z3.number()),
-        statistics: z3.object({
-          token_count: z3.number()
+var googleVertexTextEmbeddingResponseSchema = z5.object({
+  predictions: z5.array(
+    z5.object({
+      embeddings: z5.object({
+        values: z5.array(z5.number()),
+        statistics: z5.object({
+          token_count: z5.number()
         })
       })
     })
   )
 });
-var googleVertexEmbedContentResponseSchema = z3.object({
-  embedding: z3.object({
-    values: z3.array(z3.number())
+var googleVertexEmbedContentResponseSchema = z5.object({
+  embedding: z5.object({
+    values: z5.array(z5.number())
   }),
-  usageMetadata: z3.object({
-    promptTokenCount: z3.number().nullish()
+  usageMetadata: z5.object({
+    promptTokenCount: z5.number().nullish()
   }).nullish()
 });
 function usesEmbedContentEndpoint(modelId) {
@@ -254,16 +467,16 @@ function usesEmbedContentEndpoint(modelId) {
 // src/google-vertex-image-model.ts
 import { GoogleGenerativeAILanguageModel } from "@ai-sdk/google/internal";
 import {
-  combineHeaders as combineHeaders2,
-  convertToBase64,
+  combineHeaders as combineHeaders3,
+  convertToBase64 as convertToBase642,
   convertUint8ArrayToBase64,
-  createJsonResponseHandler as createJsonResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler3,
   generateId as defaultGenerateId,
-  parseProviderOptions as parseProviderOptions2,
-  postJsonToApi as postJsonToApi2,
-  resolve as resolve2
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi3,
+  resolve as resolve3
 } from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod/v4";
+import { z as z6 } from "zod/v4";
 var GoogleVertexImageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -306,7 +519,7 @@ var GoogleVertexImageModel = class {
         details: "This model does not support the `size` option. Use `aspectRatio` instead."
       });
     }
-    const vertexImageOptions = await parseProviderOptions2({
+    const vertexImageOptions = await parseProviderOptions3({
       provider: "vertex",
       providerOptions,
       schema: googleVertexImageModelOptionsSchema
@@ -368,12 +581,12 @@ var GoogleVertexImageModel = class {
       };
     }
     const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
-    const { value: response, responseHeaders } = await postJsonToApi2({
+    const { value: response, responseHeaders } = await postJsonToApi3({
       url: `${this.config.baseURL}/models/${this.modelId}:predict`,
-      headers: combineHeaders2(await resolve2(this.config.headers), headers),
+      headers: combineHeaders3(await resolve3(this.config.headers), headers),
       body,
       failedResponseHandler: googleVertexFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler2(
+      successfulResponseHandler: createJsonResponseHandler3(
         vertexImageResponseSchema
       ),
       abortSignal,
@@ -486,7 +699,7 @@ var GoogleVertexImageModel = class {
     const images = [];
     for (const part of result.content) {
       if (part.type === "file" && part.mediaType.startsWith("image/")) {
-        images.push(convertToBase64(part.data));
+        images.push(convertToBase642(part.data));
       }
     }
     return {
@@ -513,41 +726,41 @@ var GoogleVertexImageModel = class {
 function isGeminiModel(modelId) {
   return modelId.startsWith("gemini-");
 }
-var vertexImageResponseSchema = z4.object({
-  predictions: z4.array(
-    z4.object({
-      bytesBase64Encoded: z4.string(),
-      mimeType: z4.string(),
-      prompt: z4.string().nullish()
+var vertexImageResponseSchema = z6.object({
+  predictions: z6.array(
+    z6.object({
+      bytesBase64Encoded: z6.string(),
+      mimeType: z6.string(),
+      prompt: z6.string().nullish()
     })
   ).nullish()
 });
-var googleVertexImageModelOptionsSchema = z4.object({
-  negativePrompt: z4.string().nullish(),
-  personGeneration: z4.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-  safetySetting: z4.enum([
+var googleVertexImageModelOptionsSchema = z6.object({
+  negativePrompt: z6.string().nullish(),
+  personGeneration: z6.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+  safetySetting: z6.enum([
     "block_low_and_above",
     "block_medium_and_above",
     "block_only_high",
     "block_none"
   ]).nullish(),
-  addWatermark: z4.boolean().nullish(),
-  storageUri: z4.string().nullish(),
-  sampleImageSize: z4.enum(["1K", "2K"]).nullish(),
+  addWatermark: z6.boolean().nullish(),
+  storageUri: z6.string().nullish(),
+  sampleImageSize: z6.enum(["1K", "2K"]).nullish(),
   /**
    * Configuration for image editing operations
    */
-  edit: z4.object({
+  edit: z6.object({
     /**
      * An integer that represents the number of sampling steps.
      * A higher value offers better image quality, a lower value offers better latency.
      * Try 35 steps to start. If the quality doesn't meet your requirements,
      * increase the value towards an upper limit of 75.
      */
-    baseSteps: z4.number().nullish(),
+    baseSteps: z6.number().nullish(),
     // Edit mode options
     // https://cloud.google.com/vertex-ai/generative-ai/docs/image/edit-insert-objects
-    mode: z4.enum([
+    mode: z6.enum([
       "EDIT_MODE_INPAINT_INSERTION",
       "EDIT_MODE_INPAINT_REMOVAL",
       "EDIT_MODE_OUTPAINT",
@@ -563,7 +776,7 @@ var googleVertexImageModelOptionsSchema = z4.object({
      * - `MASK_MODE_CLOTHING_AREA` - Masks from segmenting the clothing area with open-vocab segmentation.
      * - `MASK_MODE_PARSED_PERSON` - Masks from segmenting the person body and clothing using the person-parsing model.
      */
-    maskMode: z4.enum([
+    maskMode: z6.enum([
       "MASK_MODE_DEFAULT",
       "MASK_MODE_USER_PROVIDED",
       "MASK_MODE_DETECTION_BOX",
@@ -575,7 +788,7 @@ var googleVertexImageModelOptionsSchema = z4.object({
      * percentage of the image width to grow the mask by. Using dilation helps
      * compensate for imprecise masks. We recommend a value of 0.01.
      */
-    maskDilation: z4.number().nullish()
+    maskDilation: z6.number().nullish()
   }).nullish()
 });
 function getBase64Data(file) {
@@ -604,28 +817,28 @@ var googleVertexTools = {
 
 // src/google-vertex-transcription-model.ts
 import {
-  combineHeaders as combineHeaders3,
+  combineHeaders as combineHeaders4,
   convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
-  createJsonResponseHandler as createJsonResponseHandler3,
-  parseProviderOptions as parseProviderOptions3,
-  postJsonToApi as postJsonToApi3,
-  resolve as resolve3
+  createJsonResponseHandler as createJsonResponseHandler4,
+  parseProviderOptions as parseProviderOptions4,
+  postJsonToApi as postJsonToApi4,
+  resolve as resolve4
 } from "@ai-sdk/provider-utils";
-import { z as z6 } from "zod/v4";
+import { z as z8 } from "zod/v4";
 
 // src/google-vertex-transcription-model-options.ts
-import { z as z5 } from "zod/v4";
-var googleVertexTranscriptionProviderOptionsSchema = z5.object({
+import { z as z7 } from "zod/v4";
+var googleVertexTranscriptionProviderOptionsSchema = z7.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: z5.array(z5.string()).optional(),
+  languageCodes: z7.array(z7.string()).optional(),
   /**
    * Whether to add punctuation to the transcript. Defaults to `true`.
    */
-  enableAutomaticPunctuation: z5.boolean().optional(),
+  enableAutomaticPunctuation: z7.boolean().optional(),
   /**
    * Whether to include word-level timestamps. Defaults to `true` so the
    * transcription result can include segments.
@@ -633,7 +846,7 @@ var googleVertexTranscriptionProviderOptionsSchema = z5.object({
    * Enabling word-level timestamps can reduce transcription quality and speed
    * for Chirp models.
    */
-  enableWordTimeOffsets: z5.boolean().optional(),
+  enableWordTimeOffsets: z7.boolean().optional(),
   /**
    * The Cloud Speech-to-Text region for the request (e.g. `'us'`, `'eu'`,
    * `'us-central1'`). Defaults to the provider `location`.
@@ -642,7 +855,7 @@ var googleVertexTranscriptionProviderOptionsSchema = z5.object({
    * available in specific Speech-to-Text regions and is not available in the
    * `global` location.
    */
-  region: z5.string().optional()
+  region: z7.string().optional()
 });
 
 // src/google-vertex-transcription-model.ts
@@ -679,7 +892,7 @@ var GoogleVertexTranscriptionModel = class {
     const warnings = [];
     let googleOptions;
     for (const provider of ["googleVertex", "vertex", "google"]) {
-      googleOptions = await parseProviderOptions3({
+      googleOptions = await parseProviderOptions4({
         provider,
         providerOptions: options.providerOptions,
         schema: googleVertexTranscriptionProviderOptionsSchema
@@ -711,15 +924,15 @@ var GoogleVertexTranscriptionModel = class {
       value: response,
       responseHeaders,
       rawValue: rawResponse
-    } = await postJsonToApi3({
+    } = await postJsonToApi4({
       url,
-      headers: combineHeaders3(
-        this.config.headers ? await resolve3(this.config.headers) : void 0,
+      headers: combineHeaders4(
+        this.config.headers ? await resolve4(this.config.headers) : void 0,
         options.headers
       ),
       body: requestBody,
       failedResponseHandler: googleVertexFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler3(
+      successfulResponseHandler: createJsonResponseHandler4(
         googleVertexTranscriptionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -758,26 +971,26 @@ var GoogleVertexTranscriptionModel = class {
     };
   }
 };
-var googleVertexTranscriptionResponseSchema = z6.object({
-  results: z6.array(
-    z6.object({
-      alternatives: z6.array(
-        z6.object({
-          transcript: z6.string().nullish(),
-          words: z6.array(
-            z6.object({
-              word: z6.string().nullish(),
-              startOffset: z6.string().nullish(),
-              endOffset: z6.string().nullish()
+var googleVertexTranscriptionResponseSchema = z8.object({
+  results: z8.array(
+    z8.object({
+      alternatives: z8.array(
+        z8.object({
+          transcript: z8.string().nullish(),
+          words: z8.array(
+            z8.object({
+              word: z8.string().nullish(),
+              startOffset: z8.string().nullish(),
+              endOffset: z8.string().nullish()
             })
           ).nullish()
         })
       ).nullish(),
-      languageCode: z6.string().nullish()
+      languageCode: z8.string().nullish()
     })
   ).nullish(),
-  metadata: z6.object({
-    totalBilledDuration: z6.string().nullish()
+  metadata: z8.object({
+    totalBilledDuration: z8.string().nullish()
   }).nullish()
 });
 
@@ -786,17 +999,17 @@ import {
   AISDKError
 } from "@ai-sdk/provider";
 import {
-  combineHeaders as combineHeaders4,
+  combineHeaders as combineHeaders5,
   convertUint8ArrayToBase64 as convertUint8ArrayToBase643,
-  createJsonResponseHandler as createJsonResponseHandler4,
+  createJsonResponseHandler as createJsonResponseHandler5,
   delay,
   lazySchema,
-  parseProviderOptions as parseProviderOptions4,
-  postJsonToApi as postJsonToApi4,
-  resolve as resolve4,
+  parseProviderOptions as parseProviderOptions5,
+  postJsonToApi as postJsonToApi5,
+  resolve as resolve5,
   zodSchema
 } from "@ai-sdk/provider-utils";
-import { z as z7 } from "zod/v4";
+import { z as z9 } from "zod/v4";
 function getFirstFrameImage(options) {
   var _a, _b;
   return (_b = (_a = options.frameImages) == null ? void 0 : _a.find((frame) => frame.frameType === "first_frame")) == null ? void 0 : _b.image;
@@ -856,7 +1069,7 @@ var GoogleVertexVideoModel = class {
     var _a, _b, _c, _d, _e, _f, _g;
     const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
     const warnings = [];
-    const vertexOptions = await parseProviderOptions4({
+    const vertexOptions = await parseProviderOptions5({
       provider: "vertex",
       providerOptions: options.providerOptions,
       schema: googleVertexVideoModelOptionsSchema
@@ -938,17 +1151,17 @@ var GoogleVertexVideoModel = class {
         }
       }
     }
-    const { value: operation } = await postJsonToApi4({
+    const { value: operation } = await postJsonToApi5({
       url: `${this.config.baseURL}/models/${this.modelId}:predictLongRunning`,
-      headers: combineHeaders4(
-        await resolve4(this.config.headers),
+      headers: combineHeaders5(
+        await resolve5(this.config.headers),
         options.headers
       ),
       body: {
         instances,
         parameters
       },
-      successfulResponseHandler: createJsonResponseHandler4(
+      successfulResponseHandler: createJsonResponseHandler5(
         vertexOperationSchema
       ),
       failedResponseHandler: googleVertexFailedResponseHandler,
@@ -981,16 +1194,16 @@ var GoogleVertexVideoModel = class {
           message: "Video generation request was aborted"
         });
       }
-      const { value: statusOperation, responseHeaders: pollHeaders } = await postJsonToApi4({
+      const { value: statusOperation, responseHeaders: pollHeaders } = await postJsonToApi5({
         url: `${this.config.baseURL}/models/${this.modelId}:fetchPredictOperation`,
-        headers: combineHeaders4(
-          await resolve4(this.config.headers),
+        headers: combineHeaders5(
+          await resolve5(this.config.headers),
           options.headers
         ),
         body: {
           operationName
         },
-        successfulResponseHandler: createJsonResponseHandler4(
+        successfulResponseHandler: createJsonResponseHandler5(
           vertexOperationSchema
         ),
         failedResponseHandler: googleVertexFailedResponseHandler,
@@ -1059,38 +1272,38 @@ var GoogleVertexVideoModel = class {
     };
   }
 };
-var vertexOperationSchema = z7.object({
-  name: z7.string().nullish(),
-  done: z7.boolean().nullish(),
-  error: z7.object({
-    code: z7.number().nullish(),
-    message: z7.string(),
-    status: z7.string().nullish()
+var vertexOperationSchema = z9.object({
+  name: z9.string().nullish(),
+  done: z9.boolean().nullish(),
+  error: z9.object({
+    code: z9.number().nullish(),
+    message: z9.string(),
+    status: z9.string().nullish()
   }).nullish(),
-  response: z7.object({
-    videos: z7.array(
-      z7.object({
-        bytesBase64Encoded: z7.string().nullish(),
-        gcsUri: z7.string().nullish(),
-        mimeType: z7.string().nullish()
+  response: z9.object({
+    videos: z9.array(
+      z9.object({
+        bytesBase64Encoded: z9.string().nullish(),
+        gcsUri: z9.string().nullish(),
+        mimeType: z9.string().nullish()
       })
     ).nullish(),
-    raiMediaFilteredCount: z7.number().nullish()
+    raiMediaFilteredCount: z9.number().nullish()
   }).nullish()
 });
 var googleVertexVideoModelOptionsSchema = lazySchema(
   () => zodSchema(
-    z7.object({
-      pollIntervalMs: z7.number().positive().nullish(),
-      pollTimeoutMs: z7.number().positive().nullish(),
-      personGeneration: z7.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-      negativePrompt: z7.string().nullish(),
-      generateAudio: z7.boolean().nullish(),
-      gcsOutputDirectory: z7.string().nullish(),
-      referenceImages: z7.array(
-        z7.object({
-          bytesBase64Encoded: z7.string().nullish(),
-          gcsUri: z7.string().nullish()
+    z9.object({
+      pollIntervalMs: z9.number().positive().nullish(),
+      pollTimeoutMs: z9.number().positive().nullish(),
+      personGeneration: z9.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+      negativePrompt: z9.string().nullish(),
+      generateAudio: z9.boolean().nullish(),
+      gcsOutputDirectory: z9.string().nullish(),
+      referenceImages: z9.array(
+        z9.object({
+          bytesBase64Encoded: z9.string().nullish(),
+          gcsUri: z9.string().nullish()
         })
       ).nullish()
     }).passthrough()
@@ -1149,7 +1362,7 @@ function createVertex(options = {}) {
   const createConfig = (name, { endpoint = false } = {}) => {
     const getHeaders = async () => {
       var _a;
-      const originalHeaders = await resolve5((_a = options.headers) != null ? _a : {});
+      const originalHeaders = await resolve6((_a = options.headers) != null ? _a : {});
       return withUserAgentSuffix(
         originalHeaders,
         `ai-sdk/google-vertex/${VERSION}`
@@ -1218,6 +1431,14 @@ function createVertex(options = {}) {
       );
     }
     const config = createConfig("transcription");
+    if (modelId.startsWith("gemini")) {
+      return new GoogleVertexGeminiTranscriptionModel(modelId, {
+        provider: config.provider,
+        baseURL: loadBaseURL(),
+        headers: config.headers,
+        fetch: config.fetch
+      });
+    }
     return new GoogleVertexTranscriptionModel(modelId, {
       provider: config.provider,
       headers: config.headers,
@@ -1267,12 +1488,13 @@ function createVertex2(options = {}) {
     ...options,
     headers: async () => ({
       Authorization: `Bearer ${await generateAuthToken()}`,
-      ...await resolve6(options.headers)
+      ...await resolve7(options.headers)
     })
   });
 }
 var vertex = createVertex2();
 export {
+  GoogleVertexGeminiTranscriptionModel,
   VERSION,
   createVertex2 as createVertex,
   vertex