@ai-sdk/google-vertex 4.0.189 → 4.0.193

package/dist/edge/index.mjs

@@ -1,5 +1,5 @@
 // src/edge/google-vertex-provider-edge.ts
-import { loadOptionalSetting as loadOptionalSetting3, resolve as resolve6 } from "@ai-sdk/provider-utils";
+import { loadOptionalSetting as loadOptionalSetting3, resolve as resolve7 } from "@ai-sdk/provider-utils";
 
 // src/google-vertex-provider.ts
 import {
@@ -11,13 +11,13 @@ 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 {
@@ -766,22 +766,235 @@ var googleVertexTranscriptionResponseSchema = z6.object({
   }).nullish()
 });
 
+// src/gemini-transcription/google-vertex-gemini-transcription-model.ts
+import {
+  InvalidArgumentError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders4,
+  convertToBase64 as convertToBase642,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  parseProviderOptions as parseProviderOptions4,
+  postJsonToApi as postJsonToApi4,
+  resolve as resolve4
+} 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
+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 parseProviderOptions4({
+        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: 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 }
+        }
+      } : {}
+    };
+  }
+};
+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 = 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 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;
@@ -841,7 +1054,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
@@ -923,17 +1136,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,
@@ -966,16 +1179,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,
@@ -1044,38 +1257,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()
@@ -1134,7 +1347,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}`
@@ -1203,6 +1416,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,
@@ -1360,7 +1581,7 @@ function createVertex2(options = {}) {
       Authorization: `Bearer ${await generateAuthToken(
         options.googleCredentials
       )}`,
-      ...await resolve6(options.headers)
+      ...await resolve7(options.headers)
     })
   });
 }