@ai-sdk/google-vertex 5.0.65 → 5.0.67

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/google-vertex-provider.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";
@@ -27,13 +27,13 @@ import {
   loadOptionalSetting,
   loadSetting,
   normalizeHeaders,
-  resolve as resolve5,
+  resolve as resolve6,
   withoutTrailingSlash,
   withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "5.0.65" : "0.0.0-test";
+var VERSION = true ? "5.0.67" : "0.0.0-test";
 
 // src/google-vertex-embedding-model.ts
 import {
@@ -753,36 +753,551 @@ var googleVertexTranscriptionResponseSchema = z6.object({
   }).nullish()
 });
 
-// src/google-vertex-video-model.ts
+// src/gemini-transcription/google-vertex-gemini-transcription-model.ts
 import {
-  AISDKError
+  InvalidArgumentError
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders4,
-  convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
+  connectToWebSocket,
+  convertToBase64 as convertToBase642,
   createJsonResponseHandler as createJsonResponseHandler4,
   parseProviderOptions as parseProviderOptions3,
   postJsonToApi as postJsonToApi4,
-  resolve as resolve4
+  resolve as resolve4,
+  safeParseJSON,
+  serializeModelOptions as serializeModelOptions5,
+  waitForWebSocketBufferDrain,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE5,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE5
 } from "@ai-sdk/provider-utils";
 import { z as z8 } from "zod/v4";
 
+// src/gemini-transcription/google-vertex-gemini-transcription-model-options.ts
+import { z as z7 } from "zod/v4";
+var googleVertexGeminiTranscriptionModelOptions = z7.object({
+  /**
+   * BCP-47 language codes providing hints about the languages present in the
+   * audio. If omitted or empty, defaults to automatic language detection.
+   */
+  languageCodes: z7.array(z7.string()).optional(),
+  /**
+   * Custom vocabulary phrases, which bias the speech recognition model
+   * toward recognizing specific terms.
+   */
+  customVocabulary: z7.array(z7.string()).optional(),
+  /**
+   * Enables word-level timestamp generation.
+   */
+  wordTimestamp: z7.boolean().optional(),
+  /**
+   * Enables speaker diarization.
+   */
+  diarization: z7.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: z7.enum(["SMART", "VERBATIM"]).optional()
+});
+
+// src/gemini-transcription/google-vertex-gemini-transcription-model.ts
+var liveWebSocketPath = "google.cloud.aiplatform.v1.LlmBidiService/BidiGenerateContent";
+var defaultFinishGraceMs = 3e3;
+function isLiveTranscriptionModelId(modelId) {
+  return modelId.includes("-live");
+}
+function vertexHost(location) {
+  if (location === "global") return "aiplatform.googleapis.com";
+  if (location === "eu" || location === "us") {
+    return `aiplatform.${location}.rep.googleapis.com`;
+  }
+  return `${location}-aiplatform.googleapis.com`;
+}
+var GoogleVertexGeminiTranscriptionModel = class _GoogleVertexGeminiTranscriptionModel {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  static [WORKFLOW_SERIALIZE5](model) {
+    return serializeModelOptions5({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE5](options) {
+    return new _GoogleVertexGeminiTranscriptionModel(
+      options.modelId,
+      options.config
+    );
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async parseOptions(providerOptions) {
+    for (const provider of ["googleVertex", "vertex", "google"]) {
+      const parsed = await parseProviderOptions3({
+        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. Use experimental_streamTranscribe, or 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: convertToBase642(options.audio)
+              }
+            }
+          ]
+        }
+      ],
+      ...audioTranscriptionConfig != null ? { generationConfig: { audioTranscriptionConfig } } : {}
+    };
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postJsonToApi4({
+      url: `${this.config.baseURL}/models/${this.modelId}:generateContent`,
+      headers: combineHeaders4(
+        this.config.headers ? await resolve4(this.config.headers) : void 0,
+        options.headers
+      ),
+      body: requestBody,
+      failedResponseHandler: googleVertexFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler4(
+        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 }
+        }
+      } : {}
+    };
+  }
+  async doStream(options) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!isLiveTranscriptionModelId(this.modelId)) {
+      throw new InvalidArgumentError({
+        argument: "modelId",
+        message: `Model '${this.modelId}' does not support streaming transcription. Use a live model such as 'gemini-3.5-transcribe-live'.`
+      });
+    }
+    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);
+    validateLiveInputAudioFormat(options.inputAudioFormat);
+    const headers = combineHeaders4(
+      this.config.headers ? await resolve4(this.config.headers) : void 0,
+      options.headers
+    );
+    const { project, location } = this.config;
+    const modelResource = `projects/${project}/locations/${location}/publishers/google/models/${this.modelId}`;
+    const url = new URL(
+      `wss://${vertexHost(location)}/ws/${liveWebSocketPath}`
+    );
+    const setup = {
+      model: modelResource,
+      inputAudioTranscription: (_d = buildAudioTranscriptionConfig(googleOptions)) != null ? _d : {}
+    };
+    return {
+      request: { body: setup },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId
+      },
+      stream: createVertexLiveTranscriptionStream({
+        webSocket: this.config.webSocket,
+        url,
+        headers,
+        setup,
+        inputAudioRate: (_e = options.inputAudioFormat.rate) != null ? _e : 16e3,
+        finishGraceMs: (_g = (_f = this.config._internal) == null ? void 0 : _f.finishGraceMs) != null ? _g : defaultFinishGraceMs,
+        warnings,
+        audio: options.audio,
+        abortSignal: options.abortSignal,
+        includeRawChunks: options.includeRawChunks
+      })
+    };
+  }
+};
+function createVertexLiveTranscriptionStream({
+  webSocket,
+  url,
+  headers,
+  setup,
+  inputAudioRate,
+  finishGraceMs,
+  warnings,
+  audio,
+  abortSignal,
+  includeRawChunks
+}) {
+  let finished = false;
+  let cleanup = () => {
+  };
+  return new ReadableStream({
+    start: (controller) => {
+      let audioReader;
+      let connection;
+      let resolveSetupComplete;
+      const setupComplete = new Promise((resolvePromise) => {
+        resolveSetupComplete = resolvePromise;
+      });
+      let segmentCounter = 0;
+      let segmentBuffer = "";
+      let fullText = "";
+      let latestInterim = "";
+      let language;
+      let audioEnded = false;
+      let usageMetadata;
+      let finishTimer;
+      const segmentId = () => `google-segment-${segmentCounter}`;
+      const cancelPendingFinish = () => {
+        if (finishTimer != null) {
+          clearTimeout(finishTimer);
+          finishTimer = void 0;
+        }
+      };
+      const schedulePendingFinish = () => {
+        if (finished || !audioEnded) return;
+        cancelPendingFinish();
+        finishTimer = setTimeout(() => {
+          finishTimer = void 0;
+          finish();
+        }, finishGraceMs);
+      };
+      cleanup = (closeCode) => {
+        cancelPendingFinish();
+        if (audioReader != null) {
+          void audioReader.cancel().catch(() => {
+          });
+        } else {
+          void audio.cancel().catch(() => {
+          });
+        }
+        connection == null ? void 0 : connection.close(closeCode);
+      };
+      const finishWithError = (error) => {
+        if (finished) return;
+        finished = true;
+        cleanup();
+        controller.error(error);
+      };
+      const completeSegment = () => {
+        if (segmentBuffer === "") {
+          if (latestInterim === "") return;
+          segmentBuffer = latestInterim;
+        }
+        latestInterim = "";
+        controller.enqueue({
+          type: "transcript-final",
+          id: segmentId(),
+          text: segmentBuffer
+        });
+        fullText += fullText === "" ? segmentBuffer : ` ${segmentBuffer}`;
+        segmentBuffer = "";
+        segmentCounter++;
+      };
+      const finish = () => {
+        if (finished) return;
+        completeSegment();
+        finished = true;
+        controller.enqueue({
+          type: "finish",
+          text: fullText,
+          segments: [],
+          language,
+          durationInSeconds: void 0,
+          ...usageMetadata != null ? { providerMetadata: { google: { usageMetadata } } } : {}
+        });
+        controller.close();
+        cleanup(1e3);
+      };
+      const sendAudio = async (socket) => {
+        audioReader = audio.getReader();
+        try {
+          while (true) {
+            const { done, value } = await audioReader.read();
+            if (done || finished) break;
+            socket.send(
+              JSON.stringify({
+                realtimeInput: {
+                  audio: {
+                    data: convertToBase642(value),
+                    mimeType: `audio/pcm;rate=${inputAudioRate}`
+                  }
+                }
+              })
+            );
+            await waitForWebSocketBufferDrain(socket);
+          }
+        } finally {
+          audioReader.releaseLock();
+          audioReader = void 0;
+        }
+        if (!finished) {
+          socket.send(
+            JSON.stringify({ realtimeInput: { audioStreamEnd: true } })
+          );
+          audioEnded = true;
+          schedulePendingFinish();
+        }
+      };
+      connection = connectToWebSocket({
+        url,
+        headers,
+        webSocket,
+        abortSignal,
+        onAbort: finishWithError,
+        onProcessingError: finishWithError,
+        onOpen: (socket) => {
+          controller.enqueue({ type: "stream-start", warnings });
+          socket.send(JSON.stringify({ setup }));
+          void setupComplete.then(() => finished ? void 0 : sendAudio(socket)).catch(finishWithError);
+        },
+        onMessageText: async (text) => {
+          var _a, _b;
+          if (finished) return;
+          const parsed = await safeParseJSON({ text });
+          if (!parsed.success) return;
+          const message = parsed.value;
+          if (includeRawChunks) {
+            controller.enqueue({ type: "raw", rawValue: message });
+          }
+          if (message.setupComplete != null) {
+            resolveSetupComplete();
+          }
+          if (message.usageMetadata != null) {
+            usageMetadata = message.usageMetadata;
+          }
+          if (message.error != null) {
+            finishWithError(
+              new Error((_a = message.error.message) != null ? _a : "Vertex Live API error")
+            );
+            return;
+          }
+          const serverContent = message.serverContent;
+          const interim = serverContent == null ? void 0 : serverContent.interimInputTranscription;
+          if (interim == null ? void 0 : interim.text) {
+            schedulePendingFinish();
+            latestInterim = interim.text;
+            controller.enqueue({
+              type: "transcript-partial",
+              id: segmentId(),
+              text: interim.text
+            });
+          }
+          const transcription = (_b = serverContent == null ? void 0 : serverContent.inputTranscription) != null ? _b : message.inputTranscription;
+          if (transcription != null) {
+            if (transcription.languageCode != null) {
+              language = transcription.languageCode;
+            }
+            if (transcription.text) {
+              schedulePendingFinish();
+              latestInterim = "";
+              segmentBuffer += transcription.text;
+              controller.enqueue({
+                type: "transcript-delta",
+                id: segmentId(),
+                delta: transcription.text
+              });
+            }
+            if (transcription.finished === true) {
+              completeSegment();
+            }
+          }
+          if (serverContent == null ? void 0 : serverContent.turnComplete) {
+            completeSegment();
+          }
+          const interactionStatus = serverContent == null ? void 0 : serverContent.interactionStatus;
+          if (audioEnded && (interactionStatus === "IDLE" || interactionStatus === "REQUIRES_ACTION" || (serverContent == null ? void 0 : serverContent.turnComplete) === true && interactionStatus == null)) {
+            finish();
+          }
+        },
+        onSocketError: () => {
+          finishWithError(
+            new Error(
+              "Vertex Live transcription error." + (webSocket == null ? " Note: the native WebSocket implementation cannot send the Authorization header required by Vertex. Pass a header-capable WebSocket implementation (e.g. the 'ws' package) via createVertex({ webSocket })." : "")
+            )
+          );
+        },
+        onClose: ({ code, reason }) => {
+          if (finished) return;
+          if (audioEnded) {
+            finish();
+            return;
+          }
+          finishWithError(
+            new Error(
+              `Vertex Live transcription WebSocket closed unexpectedly before finishing (code ${code != null ? code : "unknown"}${reason ? `, reason: ${reason}` : ""}).`
+            )
+          );
+        }
+      });
+    },
+    cancel: () => {
+      if (finished) return;
+      finished = true;
+      cleanup();
+    }
+  });
+}
+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 validateLiveInputAudioFormat(inputAudioFormat) {
+  if (inputAudioFormat.type !== "audio/pcm" || inputAudioFormat.rate != null && inputAudioFormat.rate !== 16e3) {
+    throw new InvalidArgumentError({
+      argument: "inputAudioFormat",
+      message: "The Gemini Live transcription API only supports 16kHz 16-bit PCM input audio."
+    });
+  }
+}
+function parseOffsetSeconds(offset) {
+  if (offset == null) return void 0;
+  const parsed = Number.parseFloat(offset);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+var googleVertexGeminiTranscriptionWordSchema = z8.object({
+  word: z8.string().nullish(),
+  startOffset: z8.string().nullish(),
+  endOffset: z8.string().nullish()
+});
+var googleVertexGeminiTranscriptionResponseSchema = z8.object({
+  candidates: z8.array(
+    z8.object({
+      content: z8.object({
+        parts: z8.array(
+          z8.object({
+            text: z8.string().nullish(),
+            audioTranscription: z8.object({
+              text: z8.string().nullish(),
+              languageCode: z8.string().nullish(),
+              speakerLabel: z8.string().nullish(),
+              words: z8.array(googleVertexGeminiTranscriptionWordSchema).nullish()
+            }).nullish()
+          })
+        ).nullish()
+      }).nullish()
+    })
+  ).nullish(),
+  usageMetadata: z8.record(z8.string(), z8.unknown()).nullish()
+});
+
+// src/google-vertex-video-model.ts
+import {
+  AISDKError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders5,
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
+  createJsonResponseHandler as createJsonResponseHandler5,
+  parseProviderOptions as parseProviderOptions4,
+  postJsonToApi as postJsonToApi5,
+  resolve as resolve5
+} from "@ai-sdk/provider-utils";
+import { z as z10 } from "zod/v4";
+
 // src/google-vertex-video-model-options.ts
 import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
-import { z as z7 } from "zod/v4";
+import { z as z9 } from "zod/v4";
 var googleVertexVideoModelOptionsSchema = lazySchema(
   () => zodSchema(
-    z7.looseObject({
-      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.looseObject({
+      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()
     })
@@ -848,11 +1363,11 @@ var GoogleVertexVideoModel = class {
   async buildRequest(options) {
     var _a, _b;
     const warnings = [];
-    const googleVertexOptions = (_a = await parseProviderOptions3({
+    const googleVertexOptions = (_a = await parseProviderOptions4({
       provider: "googleVertex",
       providerOptions: options.providerOptions,
       schema: googleVertexVideoModelOptionsSchema
-    })) != null ? _a : await parseProviderOptions3({
+    })) != null ? _a : await parseProviderOptions4({
       provider: "vertex",
       providerOptions: options.providerOptions,
       schema: googleVertexVideoModelOptionsSchema
@@ -1003,17 +1518,17 @@ var GoogleVertexVideoModel = class {
     var _a, _b, _c;
     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 { instances, parameters, warnings } = await this.buildRequest(options);
-    const { value: operation, responseHeaders } = await postJsonToApi4({
+    const { value: operation, responseHeaders } = 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(
         googleVertexOperationSchema
       ),
       failedResponseHandler: googleVertexFailedResponseHandler,
@@ -1041,16 +1556,16 @@ var GoogleVertexVideoModel = class {
     var _a, _b, _c;
     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 { operationName } = options.operation;
-    const { value: statusOperation, responseHeaders } = await postJsonToApi4({
+    const { value: statusOperation, responseHeaders } = 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(
         googleVertexOperationSchema
       ),
       failedResponseHandler: googleVertexFailedResponseHandler,
@@ -1086,23 +1601,23 @@ var GoogleVertexVideoModel = class {
     });
   }
 };
-var googleVertexOperationSchema = z8.object({
-  name: z8.string().nullish(),
-  done: z8.boolean().nullish(),
-  error: z8.object({
-    code: z8.number().nullish(),
-    message: z8.string(),
-    status: z8.string().nullish()
+var googleVertexOperationSchema = z10.object({
+  name: z10.string().nullish(),
+  done: z10.boolean().nullish(),
+  error: z10.object({
+    code: z10.number().nullish(),
+    message: z10.string(),
+    status: z10.string().nullish()
   }).nullish(),
-  response: z8.object({
-    videos: z8.array(
-      z8.object({
-        bytesBase64Encoded: z8.string().nullish(),
-        gcsUri: z8.string().nullish(),
-        mimeType: z8.string().nullish()
+  response: z10.object({
+    videos: z10.array(
+      z10.object({
+        bytesBase64Encoded: z10.string().nullish(),
+        gcsUri: z10.string().nullish(),
+        mimeType: z10.string().nullish()
       })
     ).nullish(),
-    raiMediaFilteredCount: z8.number().nullish()
+    raiMediaFilteredCount: z10.number().nullish()
   }).nullish()
 });
 
@@ -1162,7 +1677,7 @@ function createGoogleVertex(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}`
@@ -1253,6 +1768,17 @@ function createGoogleVertex(options = {}) {
       );
     }
     const config = createConfig("transcription");
+    if (modelId.startsWith("gemini")) {
+      return new GoogleVertexGeminiTranscriptionModel(modelId, {
+        provider: config.provider,
+        baseURL: loadBaseURL(),
+        headers: config.headers,
+        fetch: config.fetch,
+        webSocket: options.webSocket,
+        project: loadGoogleVertexProject(),
+        location: loadGoogleVertexLocation()
+      });
+    }
     return new GoogleVertexTranscriptionModel(modelId, {
       provider: config.provider,
       headers: config.headers,
@@ -1304,12 +1830,13 @@ function createGoogleVertex2(options = {}) {
     ...options,
     headers: async () => ({
       Authorization: `Bearer ${await generateAuthToken()}`,
-      ...await resolve6(options.headers)
+      ...await resolve7(options.headers)
     })
   });
 }
 var googleVertex = createGoogleVertex2();
 export {
+  GoogleVertexGeminiTranscriptionModel,
   VERSION,
   createGoogleVertex2 as createGoogleVertex,
   createGoogleVertex2 as createVertex,