@ai-sdk/google 4.0.51 → 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.51" : "0.0.0-test";
+var VERSION = true ? "4.0.54" : "0.0.0-test";
 
 // src/google-embedding-model.ts
 import {
@@ -253,18 +253,18 @@ var googleGenerativeAISingleEmbeddingResponseSchema = lazySchema3(
 
 // src/google-batch.ts
 import {
-  EmptyResponseBodyError,
   InvalidArgumentError,
   InvalidResponseDataError
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders3,
   convertAsyncIteratorToReadableStream,
+  createJsonLinesResponseHandler,
   createJsonResponseHandler as createJsonResponseHandler3,
   generateId as generateId2,
   getFromApi,
   lazySchema as lazySchema6,
-  parseJSON,
+  normalizeBatchRequestCounts,
   postJsonToApi as postJsonToApi3,
   postToApi,
   resolve as resolve3,
@@ -331,6 +331,10 @@ function convertGoogleUsage(usage) {
 import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
+var recursiveReferenceFunctionalityPrefix = "recursive JSON Schema reference:";
+function isRecursiveJSONSchemaReferenceError(error) {
+  return UnsupportedFunctionalityError.isInstance(error) && error.functionality.startsWith(recursiveReferenceFunctionalityPrefix);
+}
 function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
   const rootSchema = typeof jsonSchema === "object" ? jsonSchema : void 0;
   return convertJSONSchemaDefinition(jsonSchema, isRoot, {
@@ -471,7 +475,7 @@ function convertJSONSchemaReference({
   );
   if (referenceContext.resolvingReferences.has(referenceKey)) {
     throw new UnsupportedFunctionalityError({
-      functionality: `recursive JSON Schema reference: ${reference}`,
+      functionality: `${recursiveReferenceFunctionalityPrefix} ${reference}`,
       message: "Google schema conversion does not support recursive JSON Schema references."
     });
   }
@@ -1278,7 +1282,6 @@ function prepareTools({
   modelId,
   isVertexProvider = false
 }) {
-  var _a, _b;
   tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
   const toolWarnings = [];
   const { supportsGemini2Tools, supportsFileSearch, usesGemini3Features } = getGoogleModelCapabilities(modelId);
@@ -1396,11 +1399,7 @@ function prepareTools({
       const functionDeclarations2 = [];
       for (const tool of tools) {
         if (tool.type === "function") {
-          functionDeclarations2.push({
-            name: tool.name,
-            description: (_a = tool.description) != null ? _a : "",
-            parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema)
-          });
+          functionDeclarations2.push(prepareFunctionDeclaration(tool));
         }
       }
       const combinedToolConfig = {
@@ -1444,11 +1443,7 @@ function prepareTools({
   for (const tool of tools) {
     switch (tool.type) {
       case "function":
-        functionDeclarations.push({
-          name: tool.name,
-          description: (_b = tool.description) != null ? _b : "",
-          parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema)
-        });
+        functionDeclarations.push(prepareFunctionDeclaration(tool));
         if (tool.strict === true) {
           hasStrictTools = true;
         }
@@ -1515,6 +1510,27 @@ function prepareTools({
     }
   }
 }
+function prepareFunctionDeclaration(tool) {
+  var _a;
+  const declaration = {
+    name: tool.name,
+    description: (_a = tool.description) != null ? _a : ""
+  };
+  try {
+    return {
+      ...declaration,
+      parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema)
+    };
+  } catch (error) {
+    if (!isRecursiveJSONSchemaReferenceError(error)) {
+      throw error;
+    }
+    return {
+      ...declaration,
+      parametersJsonSchema: tool.inputSchema
+    };
+  }
+}
 
 // src/google-json-accumulator.ts
 var GoogleJSONAccumulator = class {
@@ -3254,17 +3270,19 @@ var GoogleBatchLanguageModel = class _GoogleBatchLanguageModel extends GoogleLan
       });
     }
     const encodedResponsesFile = responsesFile.split("/").map((segment) => encodeURIComponent(segment)).join("/");
-    const { value: stream } = await getFromApi({
+    const { value: lines } = await getFromApi({
       url: `${this.getBaseOrigin()}/download/v1beta/${encodedResponsesFile}:download?alt=media`,
       headers: await this.getHeaders(options.headers),
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: rawStreamResponseHandler,
+      successfulResponseHandler: createJsonLinesResponseHandler(
+        googleBatchResultLineSchema
+      ),
       abortSignal: options.abortSignal,
       fetch: this.batchConfig.fetch,
       validateUrl: false
     });
     return convertAsyncIteratorToReadableStream(
-      this.iterateBatchResults(parseJsonLines(stream))
+      this.iterateBatchResults(lines)
     );
   }
   async retrieveBatch(options) {
@@ -3430,15 +3448,12 @@ function convertGoogleRequestCounts(counts) {
   const completed = parseCount((_a = counts == null ? void 0 : counts.successfulRequestCount) != null ? _a : 0);
   const failed = parseCount((_b = counts == null ? void 0 : counts.failedRequestCount) != null ? _b : 0);
   const pending = parseCount((_c = counts == null ? void 0 : counts.pendingRequestCount) != null ? _c : 0);
-  if (total == null || completed == null || failed == null || pending == null || completed + failed + pending !== total) {
-    return void 0;
-  }
-  return {
+  return normalizeBatchRequestCounts({
     total,
     pending,
     completed,
     failed
-  };
+  });
 }
 function parseCount(value) {
   const count = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
@@ -3464,54 +3479,6 @@ var googleUploadUrlResponseHandler = async ({
   }
   return { value: uploadUrl };
 };
-var rawStreamResponseHandler = async ({ response }) => {
-  if (response.body == null) {
-    throw new EmptyResponseBodyError();
-  }
-  return { value: response.body };
-};
-async function* parseJsonLines(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let finished = false;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        finished = true;
-        buffer += decoder.decode();
-        break;
-      }
-      buffer += decoder.decode(value, { stream: true });
-      let lineEnd = buffer.indexOf("\n");
-      while (lineEnd !== -1) {
-        const line = buffer.slice(0, lineEnd).replace(/\r$/, "");
-        buffer = buffer.slice(lineEnd + 1);
-        if (line.trim().length > 0) {
-          yield await parseJSON({
-            text: line,
-            schema: googleBatchResultLineSchema
-          });
-        }
-        lineEnd = buffer.indexOf("\n");
-      }
-    }
-    const finalLine = buffer.replace(/\r$/, "");
-    if (finalLine.trim().length > 0) {
-      yield await parseJSON({
-        text: finalLine,
-        schema: googleBatchResultLineSchema
-      });
-    }
-  } finally {
-    if (!finished) {
-      await reader.cancel().catch(() => {
-      });
-    }
-    reader.releaseLock();
-  }
-}
 
 // src/tool/code-execution.ts
 import { createProviderExecutedToolFactory } from "@ai-sdk/provider-utils";
@@ -3902,6 +3869,10 @@ import {
   getFromApi as getFromApi2
 } from "@ai-sdk/provider-utils";
 import { z as z15 } from "zod/v4";
+function encodePathSegment(value) {
+  const encodedValue = encodeURIComponent(value);
+  return encodedValue === "." ? "%252E" : encodedValue === ".." ? "%252E%252E" : encodedValue;
+}
 var GoogleFiles = class {
   constructor(config) {
     this.config = config;
@@ -3963,7 +3934,7 @@ var GoogleFiles = class {
         "X-Goog-Upload-Offset": "0",
         "X-Goog-Upload-Command": "upload, finalize"
       },
-      body: fileBytes
+      body: ensureArrayBufferBacked(fileBytes)
     });
     if (!uploadResponse.ok) {
       const errorBody = await uploadResponse.text();
@@ -3985,8 +3956,10 @@ var GoogleFiles = class {
         });
       }
       await delay(pollIntervalMs);
+      const fileNameMatch = /^files\/([^/]+)$/.exec(file.name);
+      const filePath = fileNameMatch != null ? `files/${encodePathSegment(fileNameMatch[1])}` : encodePathSegment(file.name);
       const { value: fileStatus } = await getFromApi2({
-        url: `${this.config.baseURL}/${file.name}`,
+        url: `${this.config.baseURL}/${filePath}`,
         validateUrl: false,
         headers: combineHeaders4(resolvedHeaders),
         successfulResponseHandler: createJsonResponseHandler4(
@@ -4024,6 +3997,12 @@ var GoogleFiles = class {
     };
   }
 };
+function ensureArrayBufferBacked(data) {
+  if (data.buffer instanceof ArrayBuffer) {
+    return data;
+  }
+  return new Uint8Array(data);
+}
 var googleFileResponseSchema = lazySchema14(
   () => zodSchema14(
     z15.object({
@@ -4683,6 +4662,11 @@ import {
   WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE6
 } from "@ai-sdk/provider-utils";
 
+// src/interactions/build-google-interactions-stream-transform.ts
+import {
+  createProviderStreamError
+} from "@ai-sdk/provider-utils";
+
 // src/interactions/convert-google-interactions-usage.ts
 import { createNullLanguageModelUsage as createNullLanguageModelUsage2 } from "@ai-sdk/provider-utils";
 function convertGoogleInteractionsUsage(usage) {
@@ -4977,7 +4961,7 @@ function buildGoogleInteractionsStreamTransform({
       controller.enqueue({ type: "stream-start", warnings });
     },
     transform(chunk, controller) {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
       if (includeRawChunks) {
         controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
       }
@@ -5388,10 +5372,15 @@ function buildGoogleInteractionsStreamTransform({
         case "error": {
           const event = value;
           finishStatus = "failed";
-          const errorPayload = (_q = event.error) != null ? _q : {
-            message: "Unknown interaction error"
-          };
-          controller.enqueue({ type: "error", error: errorPayload });
+          controller.enqueue({
+            type: "error",
+            error: createProviderStreamError({
+              message: (_r = (_q = event.error) == null ? void 0 : _q.message) != null ? _r : "Unknown interaction error",
+              type: event.event_type,
+              code: (_t = (_s = event.error) == null ? void 0 : _s.code) != null ? _t : void 0,
+              data: event
+            })
+          });
           break;
         }
         default:
@@ -8014,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
@@ -8036,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;
 }
@@ -8065,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() {
@@ -8080,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
@@ -8107,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) {
@@ -8137,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,
@@ -8170,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 = "";
@@ -8266,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();
@@ -8288,7 +8794,7 @@ function createGoogleLiveSpeechTranslationStream({
           }
         }
       };
-      connection = connectToWebSocket({
+      connection = connectToWebSocket2({
         url,
         headers,
         webSocket,
@@ -8303,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) {
@@ -8460,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."
     });
@@ -8585,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),
     {
@@ -8639,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;
@@ -8650,6 +9165,7 @@ export {
   GoogleRealtimeModel as Experimental_GoogleRealtimeModel,
   GoogleSpeechTranslationModel as Experimental_GoogleSpeechTranslationModel,
   GoogleSpeechTranslationModel as Experimental_GoogleTranslationModel,
+  GoogleTranscriptionModel,
   VERSION,
   createGoogle,
   createGoogle as createGoogleGenerativeAI,