@ai-sdk/google 4.0.53 → 4.0.54

package/dist/index.js

@@ -7,7 +7,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "4.0.53" : "0.0.0-test";
+var VERSION = true ? "4.0.54" : "0.0.0-test";
 
 // src/google-embedding-model.ts
 import {
@@ -8003,21 +8003,538 @@ var GoogleRealtimeModel = class {
   }
 };
 
-// src/speech-translation/google-speech-translation-model.ts
+// src/transcription/google-transcription-model.ts
 import {
   InvalidArgumentError as InvalidArgumentError2
 } from "@ai-sdk/provider";
 import {
-  connectToWebSocket,
   combineHeaders as combineHeaders9,
-  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  connectToWebSocket,
   convertToBase64 as convertToBase644,
+  createJsonResponseHandler as createJsonResponseHandler9,
   parseProviderOptions as parseProviderOptions8,
+  postJsonToApi as postJsonToApi7,
+  resolve as resolve7,
   safeParseJSON as safeParseJSON2,
   serializeModelOptions as serializeModelOptions6,
+  waitForWebSocketBufferDrain,
   WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE7,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE7,
-  waitForWebSocketBufferDrain
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE7
+} from "@ai-sdk/provider-utils";
+import { z as z23 } from "zod/v4";
+
+// src/transcription/google-transcription-model-options.ts
+import { z as z22 } from "zod/v4";
+var googleTranscriptionModelOptions = z22.object({
+  /**
+   * BCP-47 language codes providing hints about the languages present in the
+   * audio. If omitted or empty, defaults to automatic language detection.
+   */
+  languageCodes: z22.array(z22.string()).optional(),
+  /**
+   * Custom vocabulary phrases, which bias the speech recognition model
+   * toward recognizing specific terms.
+   */
+  customVocabulary: z22.array(z22.string()).optional(),
+  /**
+   * Enables word-level timestamp generation.
+   */
+  wordTimestamp: z22.boolean().optional(),
+  /**
+   * Enables speaker diarization.
+   */
+  diarization: z22.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: z22.enum(["SMART", "VERBATIM"]).optional()
+});
+
+// src/transcription/google-transcription-model.ts
+var liveWebSocketPath = "google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent";
+var defaultFinishGraceMs = 3e3;
+function getLiveWebSocketURL(baseURL, apiKey) {
+  const url = getRealtimeWebSocketURL(baseURL, liveWebSocketPath);
+  url.searchParams.set("key", apiKey);
+  return url;
+}
+function isLiveTranscriptionModelId(modelId) {
+  return modelId.includes("-live");
+}
+var GoogleTranscriptionModel = class _GoogleTranscriptionModel {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  static [WORKFLOW_SERIALIZE7](model) {
+    return serializeModelOptions6({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE7](options) {
+    return new _GoogleTranscriptionModel(options.modelId, options.config);
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async parseOptions(providerOptions) {
+    return parseProviderOptions8({
+      provider: "google",
+      providerOptions,
+      schema: googleTranscriptionModelOptions
+    });
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f;
+    if (isLiveTranscriptionModelId(this.modelId)) {
+      throw new InvalidArgumentError2({
+        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 transcriptionConfig = buildTranscriptionConfig(googleOptions);
+    const requestBody = {
+      model: this.modelId,
+      input: [
+        {
+          type: "audio",
+          data: convertToBase644(options.audio),
+          mime_type: options.mediaType
+        }
+      ],
+      ...transcriptionConfig != null ? { generation_config: { transcription_config: transcriptionConfig } } : {}
+    };
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postJsonToApi7({
+      url: `${this.config.baseURL}/interactions`,
+      headers: combineHeaders9(
+        this.config.headers ? await resolve7(this.config.headers) : void 0,
+        options.headers
+      ),
+      body: requestBody,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler9(
+        googleInteractionsTranscriptionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    let text = "";
+    const segments = [];
+    for (const step of (_d = response.steps) != null ? _d : []) {
+      for (const content of (_e = step.content) != null ? _e : []) {
+        if (content.type !== "text" || content.text == null) continue;
+        text += content.text;
+        for (const annotation of (_f = content.annotations) != null ? _f : []) {
+          if (annotation.type !== "word_info") continue;
+          const startSecond = parseOffsetSeconds(annotation.start_offset);
+          const endSecond = parseOffsetSeconds(annotation.end_offset);
+          if (annotation.text == null || startSecond == null || endSecond == null) {
+            continue;
+          }
+          segments.push({ text: annotation.text, startSecond, endSecond });
+        }
+      }
+    }
+    return {
+      text,
+      segments,
+      language: void 0,
+      durationInSeconds: void 0,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      ...response.usage != null ? {
+        providerMetadata: {
+          google: { usage: response.usage }
+        }
+      } : {}
+    };
+  }
+  async doStream(options) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!isLiveTranscriptionModelId(this.modelId)) {
+      throw new InvalidArgumentError2({
+        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 = combineHeaders9(
+      this.config.headers ? await resolve7(this.config.headers) : void 0,
+      options.headers
+    );
+    let apiKey;
+    for (const [key, value] of Object.entries(headers)) {
+      if (key.toLowerCase() === "x-goog-api-key" && value != null) {
+        apiKey = value;
+      }
+    }
+    if (apiKey == null) {
+      throw new Error(
+        "Google Generative AI API key is required for streaming transcription."
+      );
+    }
+    const webSocketHeaders = Object.fromEntries(
+      Object.entries(headers).filter(
+        ([key]) => key.toLowerCase() !== "x-goog-api-key"
+      )
+    );
+    const setup = {
+      model: getModelPath(this.modelId),
+      inputAudioTranscription: (_d = buildAudioTranscriptionConfig(googleOptions)) != null ? _d : {}
+    };
+    return {
+      request: { body: setup },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId
+      },
+      stream: createGoogleLiveTranscriptionStream({
+        webSocket: this.config.webSocket,
+        url: getLiveWebSocketURL(this.config.baseURL, apiKey),
+        headers: webSocketHeaders,
+        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 createGoogleLiveTranscriptionStream({
+  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((resolve8) => {
+        resolveSetupComplete = resolve8;
+      });
+      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: convertToBase644(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 safeParseJSON2({ 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 : "Google 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("Google Live transcription error"));
+        },
+        onClose: ({ code, reason }) => {
+          if (finished) return;
+          if (audioEnded) {
+            finish();
+            return;
+          }
+          finishWithError(
+            new Error(
+              `Google 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 buildTranscriptionConfig(options) {
+  var _a;
+  if (options == null) return void 0;
+  const config = {};
+  if (options.languageCodes != null) {
+    config.language_codes = options.languageCodes;
+  }
+  if (options.customVocabulary != null) {
+    config.custom_vocabulary = options.customVocabulary;
+  }
+  if (options.mode != null || options.diarization === true || options.wordTimestamp === true) {
+    config.mode = {
+      type: ((_a = options.mode) != null ? _a : "VERBATIM").toLowerCase(),
+      ...options.diarization === true ? { diarization_mode: "speaker" } : {},
+      ...options.wordTimestamp === true ? { timestamp_granularities: ["word"] } : {}
+    };
+  }
+  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;
+}
+function validateLiveInputAudioFormat(inputAudioFormat) {
+  if (inputAudioFormat.type !== "audio/pcm" || inputAudioFormat.rate != null && inputAudioFormat.rate !== 16e3) {
+    throw new InvalidArgumentError2({
+      argument: "inputAudioFormat",
+      message: "The Gemini Live transcription API only supports 16kHz 16-bit PCM input audio."
+    });
+  }
+}
+var googleInteractionsWordAnnotationSchema = z23.object({
+  type: z23.string().nullish(),
+  text: z23.string().nullish(),
+  speaker: z23.string().nullish(),
+  start_offset: z23.string().nullish(),
+  end_offset: z23.string().nullish()
+});
+var googleInteractionsTranscriptionResponseSchema = z23.object({
+  status: z23.string().nullish(),
+  steps: z23.array(
+    z23.object({
+      type: z23.string().nullish(),
+      content: z23.array(
+        z23.object({
+          type: z23.string().nullish(),
+          text: z23.string().nullish(),
+          annotations: z23.array(googleInteractionsWordAnnotationSchema).nullish()
+        })
+      ).nullish()
+    })
+  ).nullish(),
+  usage: z23.record(z23.string(), z23.unknown()).nullish()
+});
+
+// src/speech-translation/google-speech-translation-model.ts
+import {
+  InvalidArgumentError as InvalidArgumentError3
+} from "@ai-sdk/provider";
+import {
+  connectToWebSocket as connectToWebSocket2,
+  combineHeaders as combineHeaders10,
+  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  convertToBase64 as convertToBase645,
+  parseProviderOptions as parseProviderOptions9,
+  safeParseJSON as safeParseJSON3,
+  serializeModelOptions as serializeModelOptions7,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE8,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE8,
+  waitForWebSocketBufferDrain as waitForWebSocketBufferDrain2
 } from "@ai-sdk/provider-utils";
 
 // src/speech-translation/google-speech-translation-model-options.ts
@@ -8025,26 +8542,26 @@ import {
   lazySchema as lazySchema20,
   zodSchema as zodSchema20
 } from "@ai-sdk/provider-utils";
-import { z as z22 } from "zod/v4";
+import { z as z24 } from "zod/v4";
 var googleSpeechTranslationModelOptions = lazySchema20(
   () => zodSchema20(
-    z22.object({
+    z24.object({
       /**
        * Whether input audio already in the target language should be echoed
        * instead of producing silence.
        */
-      echoTargetLanguage: z22.boolean().optional()
+      echoTargetLanguage: z24.boolean().optional()
     })
   )
 );
 
 // src/speech-translation/google-speech-translation-model.ts
-var liveWebSocketPath = "google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent";
-var defaultFinishGraceMs = 1e3;
+var liveWebSocketPath2 = "google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent";
+var defaultFinishGraceMs2 = 1e3;
 var googleLiveOutputAudioRate = 24e3;
 var pcm16SilenceAmplitudeThreshold = 128;
-function getLiveWebSocketURL(baseURL, apiKey) {
-  const url = getRealtimeWebSocketURL(baseURL, liveWebSocketPath);
+function getLiveWebSocketURL2(baseURL, apiKey) {
+  const url = getRealtimeWebSocketURL(baseURL, liveWebSocketPath2);
   url.searchParams.set("key", apiKey);
   return url;
 }
@@ -8054,13 +8571,13 @@ var GoogleSpeechTranslationModel = class _GoogleSpeechTranslationModel {
     this.modelId = modelId;
     this.config = config;
   }
-  static [WORKFLOW_SERIALIZE7](model) {
-    return serializeModelOptions6({
+  static [WORKFLOW_SERIALIZE8](model) {
+    return serializeModelOptions7({
       modelId: model.modelId,
       config: model.config
     });
   }
-  static [WORKFLOW_DESERIALIZE7](options) {
+  static [WORKFLOW_DESERIALIZE8](options) {
     return new _GoogleSpeechTranslationModel(options.modelId, options.config);
   }
   get provider() {
@@ -8069,13 +8586,13 @@ var GoogleSpeechTranslationModel = class _GoogleSpeechTranslationModel {
   async doStream(options) {
     var _a, _b, _c, _d, _e, _f;
     if (options.targetLanguage == null) {
-      throw new InvalidArgumentError2({
+      throw new InvalidArgumentError3({
         argument: "targetLanguage",
         message: `targetLanguage is required for translation model '${this.modelId}'.`
       });
     }
     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 googleOptions = await parseProviderOptions8({
+    const googleOptions = await parseProviderOptions9({
       provider: "google",
       providerOptions: options.providerOptions,
       schema: googleSpeechTranslationModelOptions
@@ -8096,7 +8613,7 @@ var GoogleSpeechTranslationModel = class _GoogleSpeechTranslationModel {
         details: "The Gemini Live API always outputs 24kHz 16-bit PCM audio and does not accept an output audio format."
       });
     }
-    const headers = combineHeaders9(this.config.headers(), options.headers);
+    const headers = combineHeaders10(this.config.headers(), options.headers);
     let apiKey;
     for (const [key, value] of Object.entries(headers)) {
       if (key.toLowerCase() === "x-goog-api-key" && value != null) {
@@ -8126,11 +8643,11 @@ var GoogleSpeechTranslationModel = class _GoogleSpeechTranslationModel {
       },
       stream: createGoogleLiveSpeechTranslationStream({
         webSocket: this.config.webSocket,
-        url: getLiveWebSocketURL(this.config.baseURL, apiKey),
+        url: getLiveWebSocketURL2(this.config.baseURL, apiKey),
         headers: webSocketHeaders,
         setup,
         inputAudioRate: (_d = options.inputAudioFormat.rate) != null ? _d : 16e3,
-        finishGraceMs: (_f = (_e = this.config._internal) == null ? void 0 : _e.finishGraceMs) != null ? _f : defaultFinishGraceMs,
+        finishGraceMs: (_f = (_e = this.config._internal) == null ? void 0 : _e.finishGraceMs) != null ? _f : defaultFinishGraceMs2,
         warnings,
         audio: options.audio,
         abortSignal: options.abortSignal,
@@ -8159,8 +8676,8 @@ function createGoogleLiveSpeechTranslationStream({
       let audioReader;
       let connection;
       let resolveSetupComplete;
-      const setupComplete = new Promise((resolve7) => {
-        resolveSetupComplete = resolve7;
+      const setupComplete = new Promise((resolve8) => {
+        resolveSetupComplete = resolve8;
       });
       let turnCounter = 0;
       let sourceText = "";
@@ -8255,13 +8772,13 @@ function createGoogleLiveSpeechTranslationStream({
               JSON.stringify({
                 realtimeInput: {
                   audio: {
-                    data: convertToBase644(value),
+                    data: convertToBase645(value),
                     mimeType: `audio/pcm;rate=${inputAudioRate}`
                   }
                 }
               })
             );
-            await waitForWebSocketBufferDrain(socket);
+            await waitForWebSocketBufferDrain2(socket);
           }
         } finally {
           audioReader.releaseLock();
@@ -8277,7 +8794,7 @@ function createGoogleLiveSpeechTranslationStream({
           }
         }
       };
-      connection = connectToWebSocket({
+      connection = connectToWebSocket2({
         url,
         headers,
         webSocket,
@@ -8292,7 +8809,7 @@ function createGoogleLiveSpeechTranslationStream({
         onMessageText: async (text) => {
           var _a, _b, _c, _d, _e, _f, _g, _h, _i;
           if (finished) return;
-          const parsed = await safeParseJSON2({ text });
+          const parsed = await safeParseJSON3({ text });
           if (!parsed.success) return;
           const message = parsed.value;
           if (includeRawChunks) {
@@ -8449,7 +8966,7 @@ function buildGoogleLiveSpeechTranslationSetup({
 }
 function validateGoogleSpeechTranslationInputAudioFormat(inputAudioFormat) {
   if (inputAudioFormat.type !== "audio/pcm" || inputAudioFormat.rate != null && inputAudioFormat.rate !== 16e3) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "inputAudioFormat",
       message: "The Gemini Live translation API only supports 16kHz 16-bit PCM input audio."
     });
@@ -8574,6 +9091,13 @@ function createGoogle(options = {}) {
     headers: getHeaders,
     fetch: options.fetch
   });
+  const createTranscriptionModel = (modelId) => new GoogleTranscriptionModel(modelId, {
+    provider: `${providerName}.transcription`,
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch,
+    webSocket: options.webSocket
+  });
   const experimentalRealtimeFactory = Object.assign(
     (modelId) => createRealtimeModel(modelId),
     {
@@ -8628,6 +9152,8 @@ function createGoogle(options = {}) {
   provider.files = createFiles;
   provider.speech = createSpeechModel;
   provider.speechModel = createSpeechModel;
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
   provider.translation = createSpeechTranslationModel;
   provider.speechTranslationModel = createSpeechTranslationModel;
   provider.interactions = createInteractionsModel;
@@ -8639,6 +9165,7 @@ export {
   GoogleRealtimeModel as Experimental_GoogleRealtimeModel,
   GoogleSpeechTranslationModel as Experimental_GoogleSpeechTranslationModel,
   GoogleSpeechTranslationModel as Experimental_GoogleTranslationModel,
+  GoogleTranscriptionModel,
   VERSION,
   createGoogle,
   createGoogle as createGoogleGenerativeAI,