@ai-sdk/google 4.0.47 → 4.0.49

package/dist/index.js

@@ -7,7 +7,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "4.0.47" : "0.0.0-test";
+var VERSION = true ? "4.0.49" : "0.0.0-test";
 
 // src/google-embedding-model.ts
 import {
@@ -303,21 +303,37 @@ import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
 function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
+  const rootSchema = typeof jsonSchema === "object" ? jsonSchema : void 0;
+  return convertJSONSchemaDefinition(jsonSchema, isRoot, {
+    definitions: rootSchema == null ? void 0 : rootSchema.definitions,
+    dollarDefinitions: rootSchema == null ? void 0 : rootSchema.$defs,
+    resolvingReferences: /* @__PURE__ */ new Set()
+  });
+}
+function convertJSONSchemaDefinition(jsonSchema, isRoot, referenceContext) {
   if (jsonSchema == null) {
     return void 0;
   }
+  if (typeof jsonSchema === "boolean") {
+    return { type: "boolean", properties: {} };
+  }
+  if (jsonSchema.$ref != null) {
+    return convertJSONSchemaReference({
+      jsonSchema,
+      reference: jsonSchema.$ref,
+      isRoot,
+      referenceContext
+    });
+  }
   if (isEmptyObjectSchema(jsonSchema)) {
     if (isRoot) {
       return void 0;
     }
-    if (typeof jsonSchema === "object" && jsonSchema.description) {
+    if (jsonSchema.description) {
       return { type: "object", description: jsonSchema.description };
     }
     return { type: "object" };
   }
-  if (typeof jsonSchema === "boolean") {
-    return { type: "boolean", properties: {} };
-  }
   const {
     type,
     description,
@@ -359,18 +375,20 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
   if (properties != null) {
     result.properties = Object.entries(properties).reduce(
       (acc, [key, value]) => {
-        acc[key] = convertJSONSchemaToOpenAPISchema(value, false);
+        acc[key] = convertJSONSchemaDefinition(value, false, referenceContext);
         return acc;
       },
       {}
     );
   }
   if (items) {
-    result.items = Array.isArray(items) ? items.map((item) => convertJSONSchemaToOpenAPISchema(item, false)) : convertJSONSchemaToOpenAPISchema(items, false);
+    result.items = Array.isArray(items) ? items.map(
+      (item) => convertJSONSchemaDefinition(item, false, referenceContext)
+    ) : convertJSONSchemaDefinition(items, false, referenceContext);
   }
   if (allOf) {
     result.allOf = allOf.map(
-      (item) => convertJSONSchemaToOpenAPISchema(item, false)
+      (item) => convertJSONSchemaDefinition(item, false, referenceContext)
     );
   }
   if (anyOf) {
@@ -381,9 +399,10 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
         (schema) => !(typeof schema === "object" && (schema == null ? void 0 : schema.type) === "null")
       );
       if (nonNullSchemas.length === 1) {
-        const converted = convertJSONSchemaToOpenAPISchema(
+        const converted = convertJSONSchemaDefinition(
           nonNullSchemas[0],
-          false
+          false,
+          referenceContext
         );
         if (typeof converted === "object") {
           result.nullable = true;
@@ -391,19 +410,19 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
         }
       } else {
         result.anyOf = nonNullSchemas.map(
-          (item) => convertJSONSchemaToOpenAPISchema(item, false)
+          (item) => convertJSONSchemaDefinition(item, false, referenceContext)
         );
         result.nullable = true;
       }
     } else {
       result.anyOf = anyOf.map(
-        (item) => convertJSONSchemaToOpenAPISchema(item, false)
+        (item) => convertJSONSchemaDefinition(item, false, referenceContext)
       );
     }
   }
   if (oneOf) {
     result.oneOf = oneOf.map(
-      (item) => convertJSONSchemaToOpenAPISchema(item, false)
+      (item) => convertJSONSchemaDefinition(item, false, referenceContext)
     );
   }
   if (minLength !== void 0) {
@@ -411,6 +430,76 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
   }
   return result;
 }
+function convertJSONSchemaReference({
+  jsonSchema,
+  reference,
+  isRoot,
+  referenceContext
+}) {
+  const { definition, referenceKey } = getReferencedDefinition(
+    reference,
+    referenceContext
+  );
+  if (referenceContext.resolvingReferences.has(referenceKey)) {
+    throw new UnsupportedFunctionalityError({
+      functionality: `recursive JSON Schema reference: ${reference}`,
+      message: "Google schema conversion does not support recursive JSON Schema references."
+    });
+  }
+  const resolvingReferences = new Set(referenceContext.resolvingReferences);
+  resolvingReferences.add(referenceKey);
+  const { $ref: _reference, ...siblingSchema } = jsonSchema;
+  const resolvedSchema = typeof definition === "boolean" ? definition ? siblingSchema : false : { ...definition, ...siblingSchema };
+  return convertJSONSchemaDefinition(resolvedSchema, isRoot, {
+    ...referenceContext,
+    resolvingReferences
+  });
+}
+function getReferencedDefinition(reference, referenceContext) {
+  const definitionSources = [
+    {
+      prefix: "#/$defs/",
+      definitions: referenceContext.dollarDefinitions
+    },
+    {
+      prefix: "#/definitions/",
+      definitions: referenceContext.definitions
+    }
+  ];
+  const source = definitionSources.find(
+    ({ prefix }) => reference.startsWith(prefix)
+  );
+  const encodedDefinitionName = source ? reference.slice(source.prefix.length) : void 0;
+  if (source == null || encodedDefinitionName == null || encodedDefinitionName.length === 0 || encodedDefinitionName.includes("/")) {
+    throwUnsupportedReference(reference);
+  }
+  let decodedDefinitionName;
+  try {
+    decodedDefinitionName = decodeURIComponent(encodedDefinitionName);
+  } catch (e) {
+    throwUnsupportedReference(reference);
+  }
+  if (decodedDefinitionName.includes("/") || /~(?![01])/u.test(decodedDefinitionName) || source.definitions == null) {
+    throwUnsupportedReference(reference);
+  }
+  const definitionName = decodedDefinitionName.replace(
+    /~[01]/g,
+    (match) => match === "~1" ? "/" : "~"
+  );
+  if (!Object.prototype.hasOwnProperty.call(source.definitions, definitionName)) {
+    throwUnsupportedReference(reference);
+  }
+  return {
+    definition: source.definitions[definitionName],
+    referenceKey: `${source.prefix}${definitionName}`
+  };
+}
+function throwUnsupportedReference(reference) {
+  throw new UnsupportedFunctionalityError({
+    functionality: `JSON Schema reference: ${reference}`,
+    message: "Google schema conversion only supports references to direct children of root-level $defs or definitions."
+  });
+}
 function addEnumToSchema({
   values,
   type,
@@ -1143,13 +1232,13 @@ function isKnownPreGemini2Model(modelId) {
   return gemini1ModelPattern.test(modelId) || /(^|\/)gemini-pro(?:-vision)?$/i.test(modelId) || /(^|\/)gemini-robotics-er-1\.5(?:[.-]|$)/i.test(modelId);
 }
 function getGoogleModelCapabilities(modelId) {
-  const isGeminiModel2 = geminiModelPattern.test(modelId);
+  const isGeminiModel = geminiModelPattern.test(modelId);
   const isGemini2Model = gemini2ModelPattern.test(modelId);
   const isKnownPreGemini2 = isKnownPreGemini2Model(modelId);
   const isKnownOlderModel = isKnownPreGemini2 || isGemini2Model;
-  const usesGemini3Features = isGeminiModel2 && !isKnownOlderModel;
+  const usesGemini3Features = isGeminiModel && !isKnownOlderModel;
   return {
-    supportsGemini2Tools: isGeminiModel2 && !isKnownPreGemini2 || modelId.toLowerCase().includes("nano-banana"),
+    supportsGemini2Tools: isGeminiModel && !isKnownPreGemini2 || modelId.toLowerCase().includes("nano-banana"),
     supportsFileSearch: gemini25ModelPattern.test(modelId) || usesGemini3Features,
     usesGemini3Features
   };
@@ -3017,32 +3106,20 @@ var googleTools = {
 
 // src/google-image-model.ts
 import {
-  combineHeaders as combineHeaders3,
   convertToBase64 as convertToBase642,
-  createJsonResponseHandler as createJsonResponseHandler3,
   generateId as defaultGenerateId,
-  lazySchema as lazySchema13,
   parseProviderOptions as parseProviderOptions3,
-  postJsonToApi as postJsonToApi3,
-  resolve as resolve3,
   serializeModelOptions as serializeModelOptions3,
   WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3,
-  zodSchema as zodSchema13
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3
 } from "@ai-sdk/provider-utils";
-import { z as z14 } from "zod/v4";
 
 // src/google-image-model-options.ts
-import {
-  lazySchema as lazySchema12,
-  zodSchema as zodSchema12
-} from "@ai-sdk/provider-utils";
+import { lazySchema as lazySchema12, zodSchema as zodSchema12 } from "@ai-sdk/provider-utils";
 import { z as z13 } from "zod/v4";
 var googleImageModelOptionsSchema = lazySchema12(
   () => zodSchema12(
     z13.object({
-      personGeneration: z13.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-      aspectRatio: z13.enum(["1:1", "3:4", "4:3", "9:16", "16:9"]).nullish(),
       /**
        * Enable Google Search grounding for Gemini image models. The value is
        * forwarded as the args of the `google.tools.googleSearch` provider
@@ -3078,121 +3155,18 @@ var GoogleImageModel = class _GoogleImageModel {
     if (this.settings.maxImagesPerCall != null) {
       return this.settings.maxImagesPerCall;
     }
-    if (isGeminiModel(this.modelId)) {
-      return 10;
-    }
-    return 4;
+    return 10;
   }
   get provider() {
     return this.config.provider;
   }
   async doGenerate(options) {
-    if (isGeminiModel(this.modelId)) {
-      return this.doGenerateGemini(options);
-    }
-    return this.doGenerateImagen(options);
-  }
-  async doGenerateImagen(options) {
-    var _a, _b, _c;
-    const {
-      prompt,
-      n = 1,
-      size,
-      aspectRatio = "1:1",
-      seed,
-      providerOptions,
-      headers,
-      abortSignal,
-      files,
-      mask
-    } = options;
-    const warnings = [];
-    if (files != null && files.length > 0) {
-      throw new Error(
-        "Google Gemini API does not support image editing with Imagen models. Use Google Vertex AI (@ai-sdk/google-vertex) for image editing capabilities."
-      );
-    }
-    if (mask != null) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    if (!this.modelId.startsWith("gemini-")) {
       throw new Error(
-        "Google Gemini API does not support image editing with masks. Use Google Vertex AI (@ai-sdk/google-vertex) for image editing capabilities."
+        "Google image models other than Gemini are no longer supported. Use a model ID that starts with `gemini-`."
       );
     }
-    if (size != null) {
-      warnings.push({
-        type: "unsupported",
-        feature: "size",
-        details: "This model does not support the `size` option. Use `aspectRatio` instead."
-      });
-    }
-    if (seed != null) {
-      warnings.push({
-        type: "unsupported",
-        feature: "seed",
-        details: "This model does not support the `seed` option through this provider."
-      });
-    }
-    const googleOptions = await parseProviderOptions3({
-      provider: "google",
-      providerOptions,
-      schema: googleImageModelOptionsSchema
-    });
-    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 parameters = {
-      sampleCount: n
-    };
-    if (aspectRatio != null) {
-      parameters.aspectRatio = aspectRatio;
-    }
-    if (googleOptions) {
-      const { googleSearch: imagenGoogleSearch, ...imagenOptions } = googleOptions;
-      if (imagenGoogleSearch != null) {
-        warnings.push({
-          type: "unsupported",
-          feature: "googleSearch",
-          details: "Google Search grounding is only supported on Gemini image models."
-        });
-      }
-      Object.assign(parameters, imagenOptions);
-    }
-    const body = {
-      instances: [{ prompt }],
-      parameters
-    };
-    const { responseHeaders, value: response } = await postJsonToApi3({
-      url: `${this.config.baseURL}/models/${this.modelId}:predict`,
-      headers: combineHeaders3(
-        this.config.headers ? await resolve3(this.config.headers) : void 0,
-        headers
-      ),
-      body,
-      failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler3(
-        googleImageResponseSchema
-      ),
-      abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      images: response.predictions.map(
-        (p) => p.bytesBase64Encoded
-      ),
-      warnings,
-      providerMetadata: {
-        google: {
-          images: response.predictions.map(() => ({
-            // Add any prediction-specific metadata here
-          }))
-        }
-      },
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders
-      }
-    };
-  }
-  async doGenerateGemini(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     const {
       prompt,
       n,
@@ -3255,7 +3229,12 @@ var GoogleImageModel = class _GoogleImageModel {
       providerOptions,
       schema: googleImageModelOptionsSchema
     });
-    const { googleSearch: _strippedGoogleSearch, ...passthroughGoogleOptions } = (_a = providerOptions == null ? void 0 : providerOptions.google) != null ? _a : {};
+    const {
+      googleSearch: _strippedGoogleSearch,
+      responseModalities: _strippedResponseModalities,
+      imageConfig: userImageConfig,
+      ...passthroughGoogleOptions
+    } = (_a = providerOptions == null ? void 0 : providerOptions.google) != null ? _a : {};
     const languageModel = new GoogleLanguageModel(this.modelId, {
       provider: this.config.provider,
       baseURL: this.config.baseURL,
@@ -3268,11 +3247,14 @@ var GoogleImageModel = class _GoogleImageModel {
       seed,
       providerOptions: {
         google: {
+          ...passthroughGoogleOptions,
           responseModalities: ["IMAGE"],
-          imageConfig: aspectRatio ? {
-            aspectRatio
-          } : void 0,
-          ...passthroughGoogleOptions
+          imageConfig: aspectRatio != null || userImageConfig != null ? {
+            ...userImageConfig,
+            ...aspectRatio != null ? {
+              aspectRatio
+            } : {}
+          } : void 0
         }
       },
       tools: (googleImageOptions == null ? void 0 : googleImageOptions.googleSearch) != null ? [
@@ -3316,32 +3298,22 @@ var GoogleImageModel = class _GoogleImageModel {
     };
   }
 };
-function isGeminiModel(modelId) {
-  return modelId.startsWith("gemini-");
-}
-var googleImageResponseSchema = lazySchema13(
-  () => zodSchema13(
-    z14.object({
-      predictions: z14.array(z14.object({ bytesBase64Encoded: z14.string() })).default([])
-    })
-  )
-);
 
 // src/google-files.ts
 import {
   AISDKError
 } from "@ai-sdk/provider";
 import {
-  combineHeaders as combineHeaders4,
+  combineHeaders as combineHeaders3,
   convertInlineFileDataToUint8Array,
-  createJsonResponseHandler as createJsonResponseHandler4,
+  createJsonResponseHandler as createJsonResponseHandler3,
   delay,
-  lazySchema as lazySchema14,
+  lazySchema as lazySchema13,
   parseProviderOptions as parseProviderOptions4,
-  zodSchema as zodSchema14,
+  zodSchema as zodSchema13,
   getFromApi
 } from "@ai-sdk/provider-utils";
-import { z as z15 } from "zod/v4";
+import { z as z14 } from "zod/v4";
 var GoogleFiles = class {
   constructor(config) {
     this.config = config;
@@ -3428,8 +3400,8 @@ var GoogleFiles = class {
       const { value: fileStatus } = await getFromApi({
         url: `${this.config.baseURL}/${file.name}`,
         validateUrl: false,
-        headers: combineHeaders4(resolvedHeaders),
-        successfulResponseHandler: createJsonResponseHandler4(
+        headers: combineHeaders3(resolvedHeaders),
+        successfulResponseHandler: createJsonResponseHandler3(
           googleFileResponseSchema
         ),
         failedResponseHandler: googleFailedResponseHandler,
@@ -3464,28 +3436,28 @@ var GoogleFiles = class {
     };
   }
 };
-var googleFileResponseSchema = lazySchema14(
-  () => zodSchema14(
-    z15.object({
-      name: z15.string(),
-      displayName: z15.string().nullish(),
-      mimeType: z15.string(),
-      sizeBytes: z15.string().nullish(),
-      createTime: z15.string().nullish(),
-      updateTime: z15.string().nullish(),
-      expirationTime: z15.string().nullish(),
-      sha256Hash: z15.string().nullish(),
-      uri: z15.string(),
-      state: z15.string()
+var googleFileResponseSchema = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      name: z14.string(),
+      displayName: z14.string().nullish(),
+      mimeType: z14.string(),
+      sizeBytes: z14.string().nullish(),
+      createTime: z14.string().nullish(),
+      updateTime: z14.string().nullish(),
+      expirationTime: z14.string().nullish(),
+      sha256Hash: z14.string().nullish(),
+      uri: z14.string(),
+      state: z14.string()
     })
   )
 );
-var googleFilesUploadOptionsSchema = lazySchema14(
-  () => zodSchema14(
-    z15.looseObject({
-      displayName: z15.string().nullish(),
-      pollIntervalMs: z15.number().positive().nullish(),
-      pollTimeoutMs: z15.number().positive().nullish()
+var googleFilesUploadOptionsSchema = lazySchema13(
+  () => zodSchema13(
+    z14.looseObject({
+      displayName: z14.string().nullish(),
+      pollIntervalMs: z14.number().positive().nullish(),
+      pollTimeoutMs: z14.number().positive().nullish()
     })
   )
 );
@@ -3495,31 +3467,31 @@ import {
   AISDKError as AISDKError2
 } from "@ai-sdk/provider";
 import {
-  combineHeaders as combineHeaders5,
+  combineHeaders as combineHeaders4,
   convertUint8ArrayToBase64,
-  createJsonResponseHandler as createJsonResponseHandler5,
+  createJsonResponseHandler as createJsonResponseHandler4,
   getFromApi as getFromApi2,
   isSameOrigin,
   parseProviderOptions as parseProviderOptions5,
-  postJsonToApi as postJsonToApi4,
-  resolve as resolve4
+  postJsonToApi as postJsonToApi3,
+  resolve as resolve3
 } from "@ai-sdk/provider-utils";
-import { z as z17 } from "zod/v4";
+import { z as z16 } from "zod/v4";
 
 // src/google-video-model-options.ts
-import { lazySchema as lazySchema15, zodSchema as zodSchema15 } from "@ai-sdk/provider-utils";
-import { z as z16 } from "zod/v4";
-var googleVideoModelOptionsSchema = lazySchema15(
-  () => zodSchema15(
-    z16.looseObject({
-      pollIntervalMs: z16.number().positive().nullish(),
-      pollTimeoutMs: z16.number().positive().nullish(),
-      personGeneration: z16.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-      negativePrompt: z16.string().nullish(),
-      referenceImages: z16.array(
-        z16.object({
-          bytesBase64Encoded: z16.string().nullish(),
-          gcsUri: z16.string().nullish()
+import { lazySchema as lazySchema14, zodSchema as zodSchema14 } from "@ai-sdk/provider-utils";
+import { z as z15 } from "zod/v4";
+var googleVideoModelOptionsSchema = lazySchema14(
+  () => zodSchema14(
+    z15.looseObject({
+      pollIntervalMs: z15.number().positive().nullish(),
+      pollTimeoutMs: z15.number().positive().nullish(),
+      personGeneration: z15.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+      negativePrompt: z15.string().nullish(),
+      referenceImages: z15.array(
+        z15.object({
+          bytesBase64Encoded: z15.string().nullish(),
+          gcsUri: z15.string().nullish()
         })
       ).nullish()
     })
@@ -3693,7 +3665,7 @@ var GoogleVideoModel = class {
     }
     const videos = [];
     const videoMetadata = [];
-    const resolvedHeaders = await resolve4(this.config.headers);
+    const resolvedHeaders = await resolve3(this.config.headers);
     const apiKey = resolvedHeaders == null ? void 0 : resolvedHeaders["x-goog-api-key"];
     for (const generatedSample of response.generateVideoResponse.generatedSamples) {
       if ((_b = generatedSample.video) == null ? void 0 : _b.uri) {
@@ -3734,17 +3706,17 @@ var GoogleVideoModel = 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 postJsonToApi3({
       url: `${this.config.baseURL}/models/${this.modelId}:predictLongRunning`,
-      headers: combineHeaders5(
-        await resolve4(this.config.headers),
+      headers: combineHeaders4(
+        await resolve3(this.config.headers),
         options.headers
       ),
       body: {
         instances,
         parameters
       },
-      successfulResponseHandler: createJsonResponseHandler5(
+      successfulResponseHandler: createJsonResponseHandler4(
         googleOperationSchema
       ),
       failedResponseHandler: googleFailedResponseHandler,
@@ -3775,11 +3747,11 @@ var GoogleVideoModel = class {
     const { value: statusOperation, responseHeaders } = await getFromApi2({
       url: `${this.config.baseURL}/${operationName}`,
       validateUrl: false,
-      headers: combineHeaders5(
-        await resolve4(this.config.headers),
+      headers: combineHeaders4(
+        await resolve3(this.config.headers),
         options.headers
       ),
-      successfulResponseHandler: createJsonResponseHandler5(
+      successfulResponseHandler: createJsonResponseHandler4(
         googleOperationSchema
       ),
       failedResponseHandler: googleFailedResponseHandler,
@@ -3815,20 +3787,20 @@ var GoogleVideoModel = class {
     );
   }
 };
-var googleOperationSchema = z17.object({
-  name: z17.string().nullish(),
-  done: z17.boolean().nullish(),
-  error: z17.object({
-    code: z17.number().nullish(),
-    message: z17.string(),
-    status: z17.string().nullish()
+var googleOperationSchema = z16.object({
+  name: z16.string().nullish(),
+  done: z16.boolean().nullish(),
+  error: z16.object({
+    code: z16.number().nullish(),
+    message: z16.string(),
+    status: z16.string().nullish()
   }).nullish(),
-  response: z17.object({
-    generateVideoResponse: z17.object({
-      generatedSamples: z17.array(
-        z17.object({
-          video: z17.object({
-            uri: z17.string().nullish()
+  response: z16.object({
+    generateVideoResponse: z16.object({
+      generatedSamples: z16.array(
+        z16.object({
+          video: z16.object({
+            uri: z16.string().nullish()
           }).nullish()
         })
       ).nullish()
@@ -3838,31 +3810,31 @@ var googleOperationSchema = z17.object({
 
 // src/google-speech-model.ts
 import {
-  combineHeaders as combineHeaders6,
+  combineHeaders as combineHeaders5,
   convertBase64ToUint8Array,
-  createJsonResponseHandler as createJsonResponseHandler6,
+  createJsonResponseHandler as createJsonResponseHandler5,
   parseProviderOptions as parseProviderOptions6,
-  postJsonToApi as postJsonToApi5,
-  resolve as resolve5,
+  postJsonToApi as postJsonToApi4,
+  resolve as resolve4,
   serializeModelOptions as serializeModelOptions4,
   WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE4,
   WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE4
 } from "@ai-sdk/provider-utils";
 
 // src/google-speech-api.ts
-import { lazySchema as lazySchema16, zodSchema as zodSchema16 } from "@ai-sdk/provider-utils";
-import { z as z18 } from "zod/v4";
-var googleSpeechResponseSchema = lazySchema16(
-  () => zodSchema16(
-    z18.object({
-      candidates: z18.array(
-        z18.object({
-          content: z18.object({
-            parts: z18.array(
-              z18.object({
-                inlineData: z18.object({
-                  mimeType: z18.string().nullish(),
-                  data: z18.string().nullish()
+import { lazySchema as lazySchema15, zodSchema as zodSchema15 } from "@ai-sdk/provider-utils";
+import { z as z17 } from "zod/v4";
+var googleSpeechResponseSchema = lazySchema15(
+  () => zodSchema15(
+    z17.object({
+      candidates: z17.array(
+        z17.object({
+          content: z17.object({
+            parts: z17.array(
+              z17.object({
+                inlineData: z17.object({
+                  mimeType: z17.string().nullish(),
+                  data: z17.string().nullish()
                 }).nullish()
               })
             ).nullish()
@@ -3875,19 +3847,19 @@ var googleSpeechResponseSchema = lazySchema16(
 
 // src/google-speech-model-options.ts
 import {
-  lazySchema as lazySchema17,
-  zodSchema as zodSchema17
+  lazySchema as lazySchema16,
+  zodSchema as zodSchema16
 } from "@ai-sdk/provider-utils";
-import { z as z19 } from "zod/v4";
-var prebuiltVoiceConfigSchema = z19.object({
-  voiceName: z19.string()
+import { z as z18 } from "zod/v4";
+var prebuiltVoiceConfigSchema = z18.object({
+  voiceName: z18.string()
 });
-var voiceConfigSchema = z19.object({
+var voiceConfigSchema = z18.object({
   prebuiltVoiceConfig: prebuiltVoiceConfigSchema
 });
-var googleSpeechProviderOptionsSchema = lazySchema17(
-  () => zodSchema17(
-    z19.object({
+var googleSpeechProviderOptionsSchema = lazySchema16(
+  () => zodSchema16(
+    z18.object({
       /**
        * Multi-speaker configuration for dialogue audio. When provided, this
        * overrides the top-level `voice`. The Gemini TTS API supports up to two
@@ -3895,10 +3867,10 @@ var googleSpeechProviderOptionsSchema = lazySchema17(
        *
        * https://ai.google.dev/gemini-api/docs/speech-generation#multi-speaker
        */
-      multiSpeakerVoiceConfig: z19.object({
-        speakerVoiceConfigs: z19.array(
-          z19.object({
-            speaker: z19.string(),
+      multiSpeakerVoiceConfig: z18.object({
+        speakerVoiceConfigs: z18.array(
+          z18.object({
+            speaker: z18.string(),
             voiceConfig: voiceConfigSchema
           })
         )
@@ -4012,15 +3984,15 @@ var GoogleSpeechModel = class _GoogleSpeechModel {
       value: response,
       responseHeaders,
       rawValue: rawResponse
-    } = await postJsonToApi5({
+    } = await postJsonToApi4({
       url: `${this.config.baseURL}/models/${this.modelId}:generateContent`,
-      headers: combineHeaders6(
-        this.config.headers ? await resolve5(this.config.headers) : void 0,
+      headers: combineHeaders5(
+        this.config.headers ? await resolve4(this.config.headers) : void 0,
         options.headers
       ),
       body: requestBody,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler6(
+      successfulResponseHandler: createJsonResponseHandler5(
         googleSpeechResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -4111,13 +4083,13 @@ function writeAscii(view, offset, text) {
 
 // src/interactions/google-interactions-language-model.ts
 import {
-  combineHeaders as combineHeaders8,
+  combineHeaders as combineHeaders7,
   createEventSourceResponseHandler as createEventSourceResponseHandler3,
-  createJsonResponseHandler as createJsonResponseHandler8,
+  createJsonResponseHandler as createJsonResponseHandler7,
   generateId as defaultGenerateId2,
   parseProviderOptions as parseProviderOptions7,
-  postJsonToApi as postJsonToApi6,
-  resolve as resolve6,
+  postJsonToApi as postJsonToApi5,
+  resolve as resolve5,
   serializeModelOptions as serializeModelOptions5,
   WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE5,
   WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE5
@@ -5253,33 +5225,33 @@ ${block.text}`
 
 // src/interactions/google-interactions-api.ts
 import {
-  lazySchema as lazySchema18,
-  zodSchema as zodSchema18
+  lazySchema as lazySchema17,
+  zodSchema as zodSchema17
 } from "@ai-sdk/provider-utils";
-import { z as z20 } from "zod/v4";
-var tokenByModalitySchema = () => z20.object({
-  modality: z20.string().nullish(),
-  tokens: z20.number().nullish()
+import { z as z19 } from "zod/v4";
+var tokenByModalitySchema = () => z19.object({
+  modality: z19.string().nullish(),
+  tokens: z19.number().nullish()
 }).loose();
-var usageSchema2 = () => z20.object({
-  total_input_tokens: z20.number().nullish(),
-  total_output_tokens: z20.number().nullish(),
-  total_thought_tokens: z20.number().nullish(),
-  total_cached_tokens: z20.number().nullish(),
-  total_tool_use_tokens: z20.number().nullish(),
-  total_tokens: z20.number().nullish(),
-  input_tokens_by_modality: z20.array(tokenByModalitySchema()).nullish(),
-  output_tokens_by_modality: z20.array(tokenByModalitySchema()).nullish(),
-  cached_tokens_by_modality: z20.array(tokenByModalitySchema()).nullish(),
-  tool_use_tokens_by_modality: z20.array(tokenByModalitySchema()).nullish(),
-  grounding_tool_count: z20.array(
-    z20.object({
-      type: z20.string().nullish(),
-      count: z20.number().nullish()
+var usageSchema2 = () => z19.object({
+  total_input_tokens: z19.number().nullish(),
+  total_output_tokens: z19.number().nullish(),
+  total_thought_tokens: z19.number().nullish(),
+  total_cached_tokens: z19.number().nullish(),
+  total_tool_use_tokens: z19.number().nullish(),
+  total_tokens: z19.number().nullish(),
+  input_tokens_by_modality: z19.array(tokenByModalitySchema()).nullish(),
+  output_tokens_by_modality: z19.array(tokenByModalitySchema()).nullish(),
+  cached_tokens_by_modality: z19.array(tokenByModalitySchema()).nullish(),
+  tool_use_tokens_by_modality: z19.array(tokenByModalitySchema()).nullish(),
+  grounding_tool_count: z19.array(
+    z19.object({
+      type: z19.string().nullish(),
+      count: z19.number().nullish()
     }).loose()
   ).nullish()
 }).loose();
-var interactionStatusSchema = () => z20.enum([
+var interactionStatusSchema = () => z19.enum([
   "in_progress",
   "requires_action",
   "completed",
@@ -5288,69 +5260,69 @@ var interactionStatusSchema = () => z20.enum([
   "incomplete"
 ]);
 var annotationSchema = () => {
-  const urlCitation = z20.object({
-    type: z20.literal("url_citation"),
-    url: z20.string().nullish(),
-    title: z20.string().nullish(),
-    start_index: z20.number().nullish(),
-    end_index: z20.number().nullish()
+  const urlCitation = z19.object({
+    type: z19.literal("url_citation"),
+    url: z19.string().nullish(),
+    title: z19.string().nullish(),
+    start_index: z19.number().nullish(),
+    end_index: z19.number().nullish()
   }).loose();
-  const fileCitation = z20.object({
-    type: z20.literal("file_citation"),
-    file_name: z20.string().nullish(),
-    document_uri: z20.string().nullish(),
-    url: z20.string().nullish(),
-    page_number: z20.number().nullish(),
-    media_id: z20.string().nullish(),
-    start_index: z20.number().nullish(),
-    end_index: z20.number().nullish(),
-    custom_metadata: z20.record(z20.string(), z20.unknown()).nullish()
+  const fileCitation = z19.object({
+    type: z19.literal("file_citation"),
+    file_name: z19.string().nullish(),
+    document_uri: z19.string().nullish(),
+    url: z19.string().nullish(),
+    page_number: z19.number().nullish(),
+    media_id: z19.string().nullish(),
+    start_index: z19.number().nullish(),
+    end_index: z19.number().nullish(),
+    custom_metadata: z19.record(z19.string(), z19.unknown()).nullish()
   }).loose();
-  const placeCitation = z20.object({
-    type: z20.literal("place_citation"),
-    name: z20.string().nullish(),
-    url: z20.string().nullish(),
-    place_id: z20.string().nullish(),
-    start_index: z20.number().nullish(),
-    end_index: z20.number().nullish()
+  const placeCitation = z19.object({
+    type: z19.literal("place_citation"),
+    name: z19.string().nullish(),
+    url: z19.string().nullish(),
+    place_id: z19.string().nullish(),
+    start_index: z19.number().nullish(),
+    end_index: z19.number().nullish()
   }).loose();
-  return z20.union([
+  return z19.union([
     urlCitation,
     fileCitation,
     placeCitation,
-    z20.object({ type: z20.string() }).loose()
+    z19.object({ type: z19.string() }).loose()
   ]);
 };
-var thoughtSummaryItemSchema = () => z20.object({
-  type: z20.string(),
-  text: z20.string().nullish(),
-  data: z20.string().nullish(),
-  mime_type: z20.string().nullish()
+var thoughtSummaryItemSchema = () => z19.object({
+  type: z19.string(),
+  text: z19.string().nullish(),
+  data: z19.string().nullish(),
+  mime_type: z19.string().nullish()
 }).loose();
 var contentBlockSchema = () => {
-  const textContent = z20.object({
-    type: z20.literal("text"),
-    text: z20.string(),
-    annotations: z20.array(annotationSchema()).nullish()
+  const textContent = z19.object({
+    type: z19.literal("text"),
+    text: z19.string(),
+    annotations: z19.array(annotationSchema()).nullish()
   }).loose();
-  const imageContent = z20.object({
-    type: z20.literal("image"),
-    data: z20.string().nullish(),
-    mime_type: z20.string().nullish(),
-    resolution: z20.enum(["low", "medium", "high", "ultra_high"]).nullish(),
-    uri: z20.string().nullish()
+  const imageContent = z19.object({
+    type: z19.literal("image"),
+    data: z19.string().nullish(),
+    mime_type: z19.string().nullish(),
+    resolution: z19.enum(["low", "medium", "high", "ultra_high"]).nullish(),
+    uri: z19.string().nullish()
   }).loose();
-  const videoContent = z20.object({
-    type: z20.literal("video"),
-    data: z20.string().nullish(),
-    mime_type: z20.string().nullish(),
-    uri: z20.string().nullish()
+  const videoContent = z19.object({
+    type: z19.literal("video"),
+    data: z19.string().nullish(),
+    mime_type: z19.string().nullish(),
+    uri: z19.string().nullish()
   }).loose();
-  return z20.union([
+  return z19.union([
     textContent,
     imageContent,
     videoContent,
-    z20.object({ type: z20.string() }).loose()
+    z19.object({ type: z19.string() }).loose()
   ]);
 };
 var BUILTIN_TOOL_CALL_STEP_TYPES = [
@@ -5370,158 +5342,158 @@ var BUILTIN_TOOL_RESULT_STEP_TYPES = [
   "mcp_server_tool_result"
 ];
 var stepSchema = () => {
-  const userInputStep = z20.object({
-    type: z20.literal("user_input"),
-    content: z20.array(contentBlockSchema()).nullish()
+  const userInputStep = z19.object({
+    type: z19.literal("user_input"),
+    content: z19.array(contentBlockSchema()).nullish()
   }).loose();
-  const modelOutputStep = z20.object({
-    type: z20.literal("model_output"),
-    content: z20.array(contentBlockSchema()).nullish()
+  const modelOutputStep = z19.object({
+    type: z19.literal("model_output"),
+    content: z19.array(contentBlockSchema()).nullish()
   }).loose();
-  const functionCallStep = z20.object({
-    type: z20.literal("function_call"),
-    id: z20.string(),
-    name: z20.string(),
-    arguments: z20.record(z20.string(), z20.unknown()).nullish(),
-    signature: z20.string().nullish()
+  const functionCallStep = z19.object({
+    type: z19.literal("function_call"),
+    id: z19.string(),
+    name: z19.string(),
+    arguments: z19.record(z19.string(), z19.unknown()).nullish(),
+    signature: z19.string().nullish()
   }).loose();
-  const thoughtStep = z20.object({
-    type: z20.literal("thought"),
-    signature: z20.string().nullish(),
-    summary: z20.array(thoughtSummaryItemSchema()).nullish()
+  const thoughtStep = z19.object({
+    type: z19.literal("thought"),
+    signature: z19.string().nullish(),
+    summary: z19.array(thoughtSummaryItemSchema()).nullish()
   }).loose();
-  const builtinToolCallStep = z20.object({
-    type: z20.enum(BUILTIN_TOOL_CALL_STEP_TYPES),
-    id: z20.string(),
-    arguments: z20.record(z20.string(), z20.unknown()).nullish(),
-    name: z20.string().nullish(),
-    server_name: z20.string().nullish(),
-    search_type: z20.string().nullish(),
-    signature: z20.string().nullish()
+  const builtinToolCallStep = z19.object({
+    type: z19.enum(BUILTIN_TOOL_CALL_STEP_TYPES),
+    id: z19.string(),
+    arguments: z19.record(z19.string(), z19.unknown()).nullish(),
+    name: z19.string().nullish(),
+    server_name: z19.string().nullish(),
+    search_type: z19.string().nullish(),
+    signature: z19.string().nullish()
   }).loose();
-  const builtinToolResultStep = z20.object({
-    type: z20.enum(BUILTIN_TOOL_RESULT_STEP_TYPES),
-    call_id: z20.string(),
-    result: z20.unknown().nullish(),
-    is_error: z20.boolean().nullish(),
-    name: z20.string().nullish(),
-    server_name: z20.string().nullish(),
-    signature: z20.string().nullish()
+  const builtinToolResultStep = z19.object({
+    type: z19.enum(BUILTIN_TOOL_RESULT_STEP_TYPES),
+    call_id: z19.string(),
+    result: z19.unknown().nullish(),
+    is_error: z19.boolean().nullish(),
+    name: z19.string().nullish(),
+    server_name: z19.string().nullish(),
+    signature: z19.string().nullish()
   }).loose();
-  return z20.union([
+  return z19.union([
     userInputStep,
     modelOutputStep,
     functionCallStep,
     thoughtStep,
     builtinToolCallStep,
     builtinToolResultStep,
-    z20.object({ type: z20.string() }).loose()
+    z19.object({ type: z19.string() }).loose()
   ]);
 };
-var googleInteractionsResponseSchema = lazySchema18(
-  () => zodSchema18(
-    z20.object({
+var googleInteractionsResponseSchema = lazySchema17(
+  () => zodSchema17(
+    z19.object({
       /*
        * `id` is omitted from the response body when `store: false` (fully
        * stateless mode) — there is no server-side interaction record for the
        * client to reference. `nullish` lets the schema accept that shape.
        */
-      id: z20.string().nullish(),
-      created: z20.string().nullish(),
-      updated: z20.string().nullish(),
+      id: z19.string().nullish(),
+      created: z19.string().nullish(),
+      updated: z19.string().nullish(),
       status: interactionStatusSchema(),
-      model: z20.string().nullish(),
-      agent: z20.string().nullish(),
-      steps: z20.array(stepSchema()).nullish(),
+      model: z19.string().nullish(),
+      agent: z19.string().nullish(),
+      steps: z19.array(stepSchema()).nullish(),
       usage: usageSchema2().nullish(),
-      service_tier: z20.string().nullish(),
-      previous_interaction_id: z20.string().nullish(),
-      response_modalities: z20.array(z20.string()).nullish()
+      service_tier: z19.string().nullish(),
+      previous_interaction_id: z19.string().nullish(),
+      response_modalities: z19.array(z19.string()).nullish()
     }).loose()
   )
 );
-var googleInteractionsEventSchema = lazySchema18(
-  () => zodSchema18(
+var googleInteractionsEventSchema = lazySchema17(
+  () => zodSchema17(
     (() => {
       const status = interactionStatusSchema();
       const annotation = annotationSchema();
       const thoughtSummaryItem = thoughtSummaryItemSchema();
-      const interactionCreatedEvent = z20.object({
-        event_type: z20.literal("interaction.created"),
-        event_id: z20.string().nullish(),
-        interaction: z20.object({
+      const interactionCreatedEvent = z19.object({
+        event_type: z19.literal("interaction.created"),
+        event_id: z19.string().nullish(),
+        interaction: z19.object({
           /*
            * `id` is omitted when `store: false` (fully stateless mode);
            * see the matching note on `googleInteractionsResponseSchema.id`.
            */
-          id: z20.string().nullish(),
-          created: z20.string().nullish(),
-          model: z20.string().nullish(),
-          agent: z20.string().nullish(),
+          id: z19.string().nullish(),
+          created: z19.string().nullish(),
+          model: z19.string().nullish(),
+          agent: z19.string().nullish(),
           status: status.nullish()
         }).loose()
       }).loose();
-      const stepStartEvent = z20.object({
-        event_type: z20.literal("step.start"),
-        event_id: z20.string().nullish(),
-        index: z20.number(),
+      const stepStartEvent = z19.object({
+        event_type: z19.literal("step.start"),
+        event_id: z19.string().nullish(),
+        index: z19.number(),
         step: stepSchema()
       }).loose();
-      const stepDeltaText = z20.object({
-        type: z20.literal("text"),
-        text: z20.string()
+      const stepDeltaText = z19.object({
+        type: z19.literal("text"),
+        text: z19.string()
       }).loose();
-      const stepDeltaThoughtSummary = z20.object({
-        type: z20.literal("thought_summary"),
+      const stepDeltaThoughtSummary = z19.object({
+        type: z19.literal("thought_summary"),
         content: thoughtSummaryItem.nullish()
       }).loose();
-      const stepDeltaThoughtSignature = z20.object({
-        type: z20.literal("thought_signature"),
-        signature: z20.string().nullish()
+      const stepDeltaThoughtSignature = z19.object({
+        type: z19.literal("thought_signature"),
+        signature: z19.string().nullish()
       }).loose();
-      const stepDeltaArgumentsDelta = z20.object({
-        type: z20.literal("arguments_delta"),
-        arguments: z20.string().nullish(),
-        id: z20.string().nullish(),
-        signature: z20.string().nullish()
+      const stepDeltaArgumentsDelta = z19.object({
+        type: z19.literal("arguments_delta"),
+        arguments: z19.string().nullish(),
+        id: z19.string().nullish(),
+        signature: z19.string().nullish()
       }).loose();
-      const stepDeltaTextAnnotation = z20.object({
-        type: z20.enum(["text_annotation_delta", "text_annotation"]),
-        annotations: z20.array(annotation).nullish()
+      const stepDeltaTextAnnotation = z19.object({
+        type: z19.enum(["text_annotation_delta", "text_annotation"]),
+        annotations: z19.array(annotation).nullish()
       }).loose();
-      const stepDeltaImage = z20.object({
-        type: z20.literal("image"),
-        data: z20.string().nullish(),
-        mime_type: z20.string().nullish(),
-        resolution: z20.enum(["low", "medium", "high", "ultra_high"]).nullish(),
-        uri: z20.string().nullish()
+      const stepDeltaImage = z19.object({
+        type: z19.literal("image"),
+        data: z19.string().nullish(),
+        mime_type: z19.string().nullish(),
+        resolution: z19.enum(["low", "medium", "high", "ultra_high"]).nullish(),
+        uri: z19.string().nullish()
       }).loose();
-      const stepDeltaVideo = z20.object({
-        type: z20.literal("video"),
-        data: z20.string().nullish(),
-        mime_type: z20.string().nullish(),
-        uri: z20.string().nullish()
+      const stepDeltaVideo = z19.object({
+        type: z19.literal("video"),
+        data: z19.string().nullish(),
+        mime_type: z19.string().nullish(),
+        uri: z19.string().nullish()
       }).loose();
-      const stepDeltaBuiltinToolCall = z20.object({
-        type: z20.enum(BUILTIN_TOOL_CALL_STEP_TYPES),
-        id: z20.string().nullish(),
-        arguments: z20.record(z20.string(), z20.unknown()).nullish(),
-        name: z20.string().nullish(),
-        server_name: z20.string().nullish(),
-        search_type: z20.string().nullish(),
-        signature: z20.string().nullish()
+      const stepDeltaBuiltinToolCall = z19.object({
+        type: z19.enum(BUILTIN_TOOL_CALL_STEP_TYPES),
+        id: z19.string().nullish(),
+        arguments: z19.record(z19.string(), z19.unknown()).nullish(),
+        name: z19.string().nullish(),
+        server_name: z19.string().nullish(),
+        search_type: z19.string().nullish(),
+        signature: z19.string().nullish()
       }).loose();
-      const stepDeltaBuiltinToolResult = z20.object({
-        type: z20.enum(BUILTIN_TOOL_RESULT_STEP_TYPES),
-        call_id: z20.string().nullish(),
-        result: z20.unknown().nullish(),
-        is_error: z20.boolean().nullish(),
-        name: z20.string().nullish(),
-        server_name: z20.string().nullish(),
-        signature: z20.string().nullish()
+      const stepDeltaBuiltinToolResult = z19.object({
+        type: z19.enum(BUILTIN_TOOL_RESULT_STEP_TYPES),
+        call_id: z19.string().nullish(),
+        result: z19.unknown().nullish(),
+        is_error: z19.boolean().nullish(),
+        name: z19.string().nullish(),
+        server_name: z19.string().nullish(),
+        signature: z19.string().nullish()
       }).loose();
-      const stepDeltaUnknown = z20.object({ type: z20.string() }).loose();
-      const stepDeltaUnion = z20.union([
+      const stepDeltaUnknown = z19.object({ type: z19.string() }).loose();
+      const stepDeltaUnion = z19.union([
         stepDeltaText,
         stepDeltaImage,
         stepDeltaVideo,
@@ -5533,55 +5505,55 @@ var googleInteractionsEventSchema = lazySchema18(
         stepDeltaBuiltinToolResult,
         stepDeltaUnknown
       ]);
-      const stepDeltaEvent = z20.object({
-        event_type: z20.literal("step.delta"),
-        event_id: z20.string().nullish(),
-        index: z20.number(),
+      const stepDeltaEvent = z19.object({
+        event_type: z19.literal("step.delta"),
+        event_id: z19.string().nullish(),
+        index: z19.number(),
         delta: stepDeltaUnion
       }).loose();
-      const stepStopEvent = z20.object({
-        event_type: z20.literal("step.stop"),
-        event_id: z20.string().nullish(),
-        index: z20.number()
+      const stepStopEvent = z19.object({
+        event_type: z19.literal("step.stop"),
+        event_id: z19.string().nullish(),
+        index: z19.number()
       }).loose();
-      const interactionStatusUpdateEvent = z20.object({
-        event_type: z20.literal("interaction.status_update"),
-        event_id: z20.string().nullish(),
-        interaction_id: z20.string().nullish(),
+      const interactionStatusUpdateEvent = z19.object({
+        event_type: z19.literal("interaction.status_update"),
+        event_id: z19.string().nullish(),
+        interaction_id: z19.string().nullish(),
         status: status.nullish()
       }).loose();
-      const interactionInProgressEvent = z20.object({
-        event_type: z20.literal("interaction.in_progress"),
-        event_id: z20.string().nullish(),
-        interaction_id: z20.string().nullish(),
+      const interactionInProgressEvent = z19.object({
+        event_type: z19.literal("interaction.in_progress"),
+        event_id: z19.string().nullish(),
+        interaction_id: z19.string().nullish(),
         status: status.nullish()
       }).loose();
-      const interactionRequiresActionEvent = z20.object({
-        event_type: z20.literal("interaction.requires_action"),
-        event_id: z20.string().nullish(),
-        interaction_id: z20.string().nullish(),
+      const interactionRequiresActionEvent = z19.object({
+        event_type: z19.literal("interaction.requires_action"),
+        event_id: z19.string().nullish(),
+        interaction_id: z19.string().nullish(),
         status: status.nullish()
       }).loose();
-      const interactionCompletedEvent = z20.object({
-        event_type: z20.literal("interaction.completed"),
-        event_id: z20.string().nullish(),
-        interaction: z20.object({
-          id: z20.string().nullish(),
+      const interactionCompletedEvent = z19.object({
+        event_type: z19.literal("interaction.completed"),
+        event_id: z19.string().nullish(),
+        interaction: z19.object({
+          id: z19.string().nullish(),
           status: status.nullish(),
           usage: usageSchema2().nullish(),
-          service_tier: z20.string().nullish()
+          service_tier: z19.string().nullish()
         }).loose()
       }).loose();
-      const errorEvent = z20.object({
-        event_type: z20.literal("error"),
-        event_id: z20.string().nullish(),
-        error: z20.object({
-          code: z20.string().nullish(),
-          message: z20.string().nullish()
+      const errorEvent = z19.object({
+        event_type: z19.literal("error"),
+        event_id: z19.string().nullish(),
+        error: z19.object({
+          code: z19.string().nullish(),
+          message: z19.string().nullish()
         }).loose().nullish()
       }).loose();
-      const unknownEvent = z20.object({ event_type: z20.string() }).loose();
-      return z20.union([
+      const unknownEvent = z19.object({ event_type: z19.string() }).loose();
+      return z19.union([
         interactionCreatedEvent,
         stepStartEvent,
         stepDeltaEvent,
@@ -5599,29 +5571,29 @@ var googleInteractionsEventSchema = lazySchema18(
 
 // src/interactions/google-interactions-language-model-options.ts
 import {
-  lazySchema as lazySchema19,
-  zodSchema as zodSchema19
+  lazySchema as lazySchema18,
+  zodSchema as zodSchema18
 } from "@ai-sdk/provider-utils";
-import { z as z21 } from "zod/v4";
-var googleInteractionsLanguageModelOptions = lazySchema19(
-  () => zodSchema19(
-    z21.object({
-      previousInteractionId: z21.string().nullish(),
-      store: z21.boolean().nullish(),
-      agent: z21.string().nullish(),
-      agentConfig: z21.union([
-        z21.object({
-          type: z21.literal("dynamic")
+import { z as z20 } from "zod/v4";
+var googleInteractionsLanguageModelOptions = lazySchema18(
+  () => zodSchema18(
+    z20.object({
+      previousInteractionId: z20.string().nullish(),
+      store: z20.boolean().nullish(),
+      agent: z20.string().nullish(),
+      agentConfig: z20.union([
+        z20.object({
+          type: z20.literal("dynamic")
         }).loose(),
-        z21.object({
-          type: z21.literal("deep-research"),
-          thinkingSummaries: z21.enum(["auto", "none"]).nullish(),
-          visualization: z21.enum(["off", "auto"]).nullish(),
-          collaborativePlanning: z21.boolean().nullish()
+        z20.object({
+          type: z20.literal("deep-research"),
+          thinkingSummaries: z20.enum(["auto", "none"]).nullish(),
+          visualization: z20.enum(["off", "auto"]).nullish(),
+          collaborativePlanning: z20.boolean().nullish()
         })
       ]).nullish(),
-      thinkingLevel: z21.enum(["minimal", "low", "medium", "high"]).nullish(),
-      thinkingSummaries: z21.enum(["auto", "none"]).nullish(),
+      thinkingLevel: z20.enum(["minimal", "low", "medium", "high"]).nullish(),
+      thinkingSummaries: z20.enum(["auto", "none"]).nullish(),
       /**
        * Output-format entries that map directly to the API's `response_format`
        * array. Use this to request image, audio, or non-JSON text outputs
@@ -5631,17 +5603,17 @@ var googleInteractionsLanguageModelOptions = lazySchema19(
        * type: 'json', schema }` still drives JSON-mode and adds a matching
        * text entry automatically; entries listed here are appended.
        */
-      responseFormat: z21.array(
-        z21.union([
-          z21.object({
-            type: z21.literal("text"),
-            mimeType: z21.string().nullish(),
-            schema: z21.unknown().nullish()
+      responseFormat: z20.array(
+        z20.union([
+          z20.object({
+            type: z20.literal("text"),
+            mimeType: z20.string().nullish(),
+            schema: z20.unknown().nullish()
           }).loose(),
-          z21.object({
-            type: z21.literal("image"),
-            mimeType: z21.string().nullish(),
-            aspectRatio: z21.enum([
+          z20.object({
+            type: z20.literal("image"),
+            mimeType: z20.string().nullish(),
+            aspectRatio: z20.enum([
               "1:1",
               "2:3",
               "3:2",
@@ -5657,11 +5629,11 @@ var googleInteractionsLanguageModelOptions = lazySchema19(
               "1:4",
               "4:1"
             ]).nullish(),
-            imageSize: z21.enum(["1K", "2K", "4K", "512"]).nullish()
+            imageSize: z20.enum(["1K", "2K", "4K", "512"]).nullish()
           }).loose(),
-          z21.object({
-            type: z21.literal("audio"),
-            mimeType: z21.string().nullish()
+          z20.object({
+            type: z20.literal("audio"),
+            mimeType: z20.string().nullish()
           }).loose()
         ])
       ).nullish(),
@@ -5671,8 +5643,8 @@ var googleInteractionsLanguageModelOptions = lazySchema19(
        * translates it into a matching `response_format` image entry and
        * emits a warning when set.
        */
-      imageConfig: z21.object({
-        aspectRatio: z21.enum([
+      imageConfig: z20.object({
+        aspectRatio: z20.enum([
           "1:1",
           "2:3",
           "3:2",
@@ -5688,35 +5660,35 @@ var googleInteractionsLanguageModelOptions = lazySchema19(
           "1:4",
           "4:1"
         ]).nullish(),
-        imageSize: z21.enum(["1K", "2K", "4K", "512"]).nullish()
+        imageSize: z20.enum(["1K", "2K", "4K", "512"]).nullish()
       }).nullish(),
-      mediaResolution: z21.enum(["low", "medium", "high", "ultra_high"]).nullish(),
-      responseModalities: z21.array(z21.enum(["text", "image", "audio", "video", "document"])).nullish(),
-      serviceTier: z21.enum(["flex", "standard", "priority"]).nullish(),
+      mediaResolution: z20.enum(["low", "medium", "high", "ultra_high"]).nullish(),
+      responseModalities: z20.array(z20.enum(["text", "image", "audio", "video", "document"])).nullish(),
+      serviceTier: z20.enum(["flex", "standard", "priority"]).nullish(),
       /**
        * Alternative to AI SDK `system` message. If both are set, the AI SDK
        * `system` message wins and a warning is emitted.
        */
-      systemInstruction: z21.string().nullish(),
+      systemInstruction: z20.string().nullish(),
       /**
        * Per-block signature for round-tripping `thought.signature` and
        * `function_call.signature` blocks. Set by the SDK on output reasoning /
        * tool-call parts; passed back unchanged on input parts so the API
        * accepts the prior turn.
        */
-      signature: z21.string().nullish(),
+      signature: z20.string().nullish(),
       /**
        * Set by the SDK on output assistant messages. The converter uses it to
        * decide which messages to drop when compacting under
        * `previousInteractionId`.
        */
-      interactionId: z21.string().nullish(),
+      interactionId: z20.string().nullish(),
       /**
        * Maximum time, in milliseconds, to poll a background interaction (agent
        * call) before giving up. Defaults to 30 minutes. Long-running agents
        * such as deep research can take tens of minutes — increase if needed.
        */
-      pollingTimeoutMs: z21.number().int().positive().nullish(),
+      pollingTimeoutMs: z20.number().int().positive().nullish(),
       /**
        * Run the interaction in the background. Required for agents whose
        * server-side workflow cannot complete within a single request/response.
@@ -5725,7 +5697,7 @@ var googleInteractionsLanguageModelOptions = lazySchema19(
        * reject `true`; see the agent's documentation for which mode it
        * requires.
        */
-      background: z21.boolean().nullish(),
+      background: z20.boolean().nullish(),
       /**
        * Environment configuration for the agent sandbox. Only applies to agent
        * calls (`google.interactions({ agent })`); ignored on model-id calls.
@@ -5735,36 +5707,36 @@ var googleInteractionsLanguageModelOptions = lazySchema19(
        *   - object: provision a fresh sandbox and optionally preload `sources`
        *     and/or constrain outbound traffic via `network`.
        */
-      environment: z21.union([
-        z21.string(),
-        z21.object({
-          type: z21.literal("remote"),
-          sources: z21.array(
-            z21.union([
-              z21.object({
-                type: z21.literal("gcs"),
-                source: z21.string(),
-                target: z21.string().nullish()
+      environment: z20.union([
+        z20.string(),
+        z20.object({
+          type: z20.literal("remote"),
+          sources: z20.array(
+            z20.union([
+              z20.object({
+                type: z20.literal("gcs"),
+                source: z20.string(),
+                target: z20.string().nullish()
               }),
-              z21.object({
-                type: z21.literal("repository"),
-                source: z21.string(),
-                target: z21.string().nullish()
+              z20.object({
+                type: z20.literal("repository"),
+                source: z20.string(),
+                target: z20.string().nullish()
               }),
-              z21.object({
-                type: z21.literal("inline"),
-                content: z21.string(),
-                target: z21.string()
+              z20.object({
+                type: z20.literal("inline"),
+                content: z20.string(),
+                target: z20.string()
               })
             ])
           ).nullish(),
-          network: z21.union([
-            z21.literal("disabled"),
-            z21.object({
-              allowlist: z21.array(
-                z21.object({
-                  domain: z21.string(),
-                  transform: z21.array(z21.record(z21.string(), z21.string())).nullish()
+          network: z20.union([
+            z20.literal("disabled"),
+            z20.object({
+              allowlist: z20.array(
+                z20.object({
+                  domain: z20.string(),
+                  transform: z20.array(z20.record(z20.string(), z20.string())).nullish()
                 })
               )
             })
@@ -5954,7 +5926,7 @@ function parseGoogleInteractionsOutputs({
 
 // src/interactions/poll-google-interactions.ts
 import {
-  createJsonResponseHandler as createJsonResponseHandler7,
+  createJsonResponseHandler as createJsonResponseHandler6,
   delay as delay2,
   getFromApi as getFromApi3,
   isAbortError
@@ -5962,7 +5934,7 @@ import {
 
 // src/interactions/cancel-google-interaction.ts
 import {
-  combineHeaders as combineHeaders7,
+  combineHeaders as combineHeaders6,
   getRuntimeEnvironmentUserAgent,
   withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
@@ -5981,7 +5953,7 @@ async function cancelGoogleInteraction({
     const response = await fetch2(url, {
       method: "POST",
       headers: withUserAgentSuffix(
-        combineHeaders7({ "Content-Type": "application/json" }, headers),
+        combineHeaders6({ "Content-Type": "application/json" }, headers),
         getRuntimeEnvironmentUserAgent()
       ),
       body: "{}"
@@ -6042,7 +6014,7 @@ async function pollGoogleInteractionUntilTerminal({
         validateUrl: false,
         headers,
         failedResponseHandler: googleFailedResponseHandler,
-        successfulResponseHandler: createJsonResponseHandler7(
+        successfulResponseHandler: createJsonResponseHandler6(
           googleInteractionsResponseSchema
         ),
         abortSignal,
@@ -6818,16 +6790,16 @@ var GoogleInteractionsLanguageModel = class _GoogleInteractionsLanguageModel {
     var _a, _b, _c, _d, _e, _f;
     const { args, warnings, isAgent, pollingTimeoutMs } = await this.getArgs(options);
     const url = `${this.config.baseURL}/interactions`;
-    const mergedHeaders = combineHeaders8(
-      this.config.headers ? await resolve6(this.config.headers) : void 0,
+    const mergedHeaders = combineHeaders7(
+      this.config.headers ? await resolve5(this.config.headers) : void 0,
       options.headers
     );
-    const postResult = await postJsonToApi6({
+    const postResult = await postJsonToApi5({
       url,
       headers: mergedHeaders,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler8(
+      successfulResponseHandler: createJsonResponseHandler7(
         googleInteractionsResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -6902,8 +6874,8 @@ var GoogleInteractionsLanguageModel = class _GoogleInteractionsLanguageModel {
     var _a;
     const { args, warnings, isBackground, pollingTimeoutMs } = await this.getArgs(options);
     const url = `${this.config.baseURL}/interactions`;
-    const mergedHeaders = combineHeaders8(
-      this.config.headers ? await resolve6(this.config.headers) : void 0,
+    const mergedHeaders = combineHeaders7(
+      this.config.headers ? await resolve5(this.config.headers) : void 0,
       options.headers
     );
     if (isBackground) {
@@ -6917,7 +6889,7 @@ var GoogleInteractionsLanguageModel = class _GoogleInteractionsLanguageModel {
       });
     }
     const body = { ...args, stream: true };
-    const { responseHeaders, value: response } = await postJsonToApi6({
+    const { responseHeaders, value: response } = await postJsonToApi5({
       url,
       headers: mergedHeaders,
       body,
@@ -6968,12 +6940,12 @@ var GoogleInteractionsLanguageModel = class _GoogleInteractionsLanguageModel {
     pollingTimeoutMs
   }) {
     var _a, _b;
-    const postResult = await postJsonToApi6({
+    const postResult = await postJsonToApi5({
       url,
       headers: mergedHeaders,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler8(
+      successfulResponseHandler: createJsonResponseHandler7(
         googleInteractionsResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -7460,7 +7432,7 @@ import {
 } from "@ai-sdk/provider";
 import {
   connectToWebSocket,
-  combineHeaders as combineHeaders9,
+  combineHeaders as combineHeaders8,
   convertBase64ToUint8Array as convertBase64ToUint8Array2,
   convertToBase64 as convertToBase644,
   parseProviderOptions as parseProviderOptions8,
@@ -7473,18 +7445,18 @@ import {
 
 // src/speech-translation/google-speech-translation-model-options.ts
 import {
-  lazySchema as lazySchema20,
-  zodSchema as zodSchema20
+  lazySchema as lazySchema19,
+  zodSchema as zodSchema19
 } from "@ai-sdk/provider-utils";
-import { z as z22 } from "zod/v4";
-var googleSpeechTranslationModelOptions = lazySchema20(
-  () => zodSchema20(
-    z22.object({
+import { z as z21 } from "zod/v4";
+var googleSpeechTranslationModelOptions = lazySchema19(
+  () => zodSchema19(
+    z21.object({
       /**
        * Whether input audio already in the target language should be echoed
        * instead of producing silence.
        */
-      echoTargetLanguage: z22.boolean().optional()
+      echoTargetLanguage: z21.boolean().optional()
     })
   )
 );
@@ -7547,7 +7519,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 = combineHeaders8(this.config.headers(), options.headers);
     let apiKey;
     for (const [key, value] of Object.entries(headers)) {
       if (key.toLowerCase() === "x-goog-api-key" && value != null) {
@@ -7610,8 +7582,8 @@ function createGoogleLiveSpeechTranslationStream({
       let audioReader;
       let connection;
       let resolveSetupComplete;
-      const setupComplete = new Promise((resolve7) => {
-        resolveSetupComplete = resolve7;
+      const setupComplete = new Promise((resolve6) => {
+        resolveSetupComplete = resolve6;
       });
       let turnCounter = 0;
       let sourceText = "";