@ai-sdk/google 3.0.24 → 3.0.26

package/docs/15-google-generative-ai.mdx

@@ -108,6 +108,8 @@ Google Generative AI also supports some model specific settings that are not par
 You can pass them as an options argument:
 
 ```ts
+import { google, type GoogleLanguageModelOptions } from '@ai-sdk/google';
+
 const model = google('gemini-2.5-flash');
 
 await generateText({
@@ -120,7 +122,7 @@ await generateText({
           threshold: 'BLOCK_LOW_AND_ABOVE',
         },
       ],
-    },
+    } satisfies GoogleLanguageModelOptions,
   },
 });
 ```
@@ -256,7 +258,7 @@ The Gemini 2.5 and Gemini 3 series models use an internal "thinking process" tha
 For Gemini 3 models, use the `thinkingLevel` parameter to control the depth of reasoning:
 
 ```ts
-import { google, GoogleGenerativeAIProviderOptions } from '@ai-sdk/google';
+import { google, GoogleLanguageModelOptions } from '@ai-sdk/google';
 import { generateText } from 'ai';
 
 const model = google('gemini-3-pro-preview');
@@ -270,7 +272,7 @@ const { text, reasoning } = await generateText({
         thinkingLevel: 'high',
         includeThoughts: true,
       },
-    } satisfies GoogleGenerativeAIProviderOptions,
+    } satisfies GoogleLanguageModelOptions,
   },
 });
 
@@ -284,7 +286,7 @@ console.log(reasoning); // Reasoning summary
 For Gemini 2.5 models, use the `thinkingBudget` parameter to control the number of thinking tokens:
 
 ```ts
-import { google, GoogleGenerativeAIProviderOptions } from '@ai-sdk/google';
+import { google, GoogleLanguageModelOptions } from '@ai-sdk/google';
 import { generateText } from 'ai';
 
 const model = google('gemini-2.5-flash');
@@ -298,7 +300,7 @@ const { text, reasoning } = await generateText({
         thinkingBudget: 8192,
         includeThoughts: true,
       },
-    } satisfies GoogleGenerativeAIProviderOptions,
+    } satisfies GoogleLanguageModelOptions,
   },
 });
 
@@ -435,7 +437,7 @@ console.log('Cached tokens:', providerMetadata.google);
 For guaranteed cost savings, you can still use explicit caching with Gemini 2.5 and 2.0 models. See the [models page](https://ai.google.dev/gemini-api/docs/models) to check if caching is supported for the used model:
 
 ```ts
-import { google } from '@ai-sdk/google';
+import { google, type GoogleLanguageModelOptions } from '@ai-sdk/google';
 import { GoogleGenAI } from '@google/genai';
 import { generateText } from 'ai';
 
@@ -465,7 +467,7 @@ const { text: veggieLasagnaRecipe } = await generateText({
   providerOptions: {
     google: {
       cachedContent: cache.name,
-    },
+    } satisfies GoogleLanguageModelOptions,
   },
 });
 
@@ -475,7 +477,7 @@ const { text: meatLasagnaRecipe } = await generateText({
   providerOptions: {
     google: {
       cachedContent: cache.name,
-    },
+    } satisfies GoogleLanguageModelOptions,
   },
 });
 ```
@@ -766,7 +768,7 @@ With [Google Maps grounding](https://ai.google.dev/gemini-api/docs/maps-groundin
 the model has access to Google Maps data for location-aware responses. This enables providing local data and geospatial context, such as finding nearby restaurants.
 
 ```ts highlight="7-16"
-import { google } from '@ai-sdk/google';
+import { google, type GoogleLanguageModelOptions } from '@ai-sdk/google';
 import { GoogleGenerativeAIProviderMetadata } from '@ai-sdk/google';
 import { generateText } from 'ai';
 
@@ -780,7 +782,7 @@ const { text, sources, providerMetadata } = await generateText({
       retrievalConfig: {
         latLng: { latitude: 34.090199, longitude: -117.881081 },
       },
-    },
+    } satisfies GoogleLanguageModelOptions,
   },
   prompt:
     'What are the best Italian restaurants within a 15-minute walk from here?',
@@ -927,7 +929,7 @@ The `vertexRagStore` tool accepts the following configuration options:
 
 ### Image Outputs
 
-Gemini models with image generation capabilities (`gemini-2.5-flash-image`) support image generation. Images are exposed as files in the response.
+Gemini models with image generation capabilities (e.g. `gemini-2.5-flash-image`) support generating images as part of a multimodal response. Images are exposed as files in the response.
 
 ```ts
 import { google } from '@ai-sdk/google';
@@ -946,6 +948,12 @@ for (const file of result.files) {
 }
 ```
 
+<Note>
+  If you primarily want to generate images without text output, you can also use
+  Gemini image models with the `generateImage()` function. See [Gemini Image
+  Models](#gemini-image-models) for details.
+</Note>
+
 ### Safety Ratings
 
 The safety ratings provide insight into the safety of the model's response.
@@ -1008,7 +1016,7 @@ const { object } = await generateObject({
   providerOptions: {
     google: {
       structuredOutputs: false,
-    },
+    } satisfies GoogleLanguageModelOptions,
   },
   schema: z.object({
     name: z.string(),
@@ -1099,7 +1107,7 @@ The Google Generative AI provider sends API calls to the right endpoint based on
 Google Generative AI embedding models support aditional settings. You can pass them as an options argument:
 
 ```ts
-import { google } from '@ai-sdk/google';
+import { google, type GoogleEmbeddingModelOptions } from '@ai-sdk/google';
 import { embed } from 'ai';
 
 const model = google.embedding('gemini-embedding-001');
@@ -1111,7 +1119,7 @@ const { embedding } = await embed({
     google: {
       outputDimensionality: 512, // optional, number of dimensions for the embedding
       taskType: 'SEMANTIC_SIMILARITY', // optional, specifies the task type for generating embeddings
-    },
+    } satisfies GoogleEmbeddingModelOptions,
   },
 });
 ```
@@ -1144,9 +1152,18 @@ The following optional provider options are available for Google Generative AI e
 
 ## Image Models
 
-You can create [Imagen](https://ai.google.dev/gemini-api/docs/imagen) models that call the Google Generative AI API using the `.image()` factory method.
+You can create image models that call the Google Generative AI API using the `.image()` factory method.
 For more on image generation with the AI SDK see [generateImage()](/docs/reference/ai-sdk-core/generate-image).
 
+The Google provider supports two types of image models:
+
+- **Imagen models**: Dedicated image generation models using the `:predict` API
+- **Gemini image models**: Multimodal language models with image output capabilities using the `:generateContent` API
+
+### Imagen Models
+
+[Imagen](https://ai.google.dev/gemini-api/docs/imagen) models are dedicated image generation models.
+
 ```ts
 import { google } from '@ai-sdk/google';
 import { generateImage } from 'ai';
@@ -1158,11 +1175,11 @@ const { image } = await generateImage({
 });
 ```
 
-Further configuration can be done using Google provider options. You can validate the provider options using the `GoogleGenerativeAIImageProviderOptions` type.
+Further configuration can be done using Google provider options. You can validate the provider options using the `GoogleImageModelOptions` type.
 
 ```ts
 import { google } from '@ai-sdk/google';
-import { GoogleGenerativeAIImageProviderOptions } from '@ai-sdk/google';
+import { GoogleImageModelOptions } from '@ai-sdk/google';
 import { generateImage } from 'ai';
 
 const { image } = await generateImage({
@@ -1170,13 +1187,13 @@ const { image } = await generateImage({
   providerOptions: {
     google: {
       personGeneration: 'dont_allow',
-    } satisfies GoogleGenerativeAIImageProviderOptions,
+    } satisfies GoogleImageModelOptions,
   },
   // ...
 });
 ```
 
-The following provider options are available:
+The following provider options are available for Imagen models:
 
 - **personGeneration** `allow_adult` | `allow_all` | `dont_allow`
   Whether to allow person generation. Defaults to `allow_adult`.
@@ -1186,10 +1203,84 @@ The following provider options are available:
   parameter instead.
 </Note>
 
-#### Model Capabilities
+#### Imagen Model Capabilities
 
 | Model                           | Aspect Ratios             |
 | ------------------------------- | ------------------------- |
 | `imagen-4.0-generate-001`       | 1:1, 3:4, 4:3, 9:16, 16:9 |
 | `imagen-4.0-ultra-generate-001` | 1:1, 3:4, 4:3, 9:16, 16:9 |
 | `imagen-4.0-fast-generate-001`  | 1:1, 3:4, 4:3, 9:16, 16:9 |
+
+### Gemini Image Models
+
+[Gemini image models](https://ai.google.dev/gemini-api/docs/image-generation) (e.g. `gemini-2.5-flash-image`) are technically multimodal output language models, but they can be used with the `generateImage()` function for a simpler image generation experience. Internally, the provider calls the language model API with `responseModalities: ['IMAGE']`.
+
+```ts
+import { google } from '@ai-sdk/google';
+import { generateImage } from 'ai';
+
+const { image } = await generateImage({
+  model: google.image('gemini-2.5-flash-image'),
+  prompt: 'A photorealistic image of a cat wearing a wizard hat',
+  aspectRatio: '1:1',
+});
+```
+
+Gemini image models also support image editing by providing input images:
+
+```ts
+import { google } from '@ai-sdk/google';
+import { generateImage } from 'ai';
+import fs from 'node:fs';
+
+const sourceImage = fs.readFileSync('./cat.png');
+
+const { image } = await generateImage({
+  model: google.image('gemini-2.5-flash-image'),
+  prompt: {
+    text: 'Add a small wizard hat to this cat',
+    images: [sourceImage],
+  },
+});
+```
+
+You can also use URLs for input images:
+
+```ts
+import { google } from '@ai-sdk/google';
+import { generateImage } from 'ai';
+
+const { image } = await generateImage({
+  model: google.image('gemini-2.5-flash-image'),
+  prompt: {
+    text: 'Add a small wizard hat to this cat',
+    images: ['https://example.com/cat.png'],
+  },
+});
+```
+
+<Note>
+  Gemini image models do not support the `size` or `n` parameters. Use
+  `aspectRatio` instead of `size`. Mask-based inpainting is also not supported.
+</Note>
+
+<Note>
+  For more advanced use cases where you need both text and image outputs, or
+  want more control over the generation process, you can use Gemini image models
+  directly with `generateText()`. See [Image Outputs](#image-outputs) for
+  details.
+</Note>
+
+#### Gemini Image Model Capabilities
+
+| Model                        | Image Generation    | Image Editing       | Aspect Ratios                                       |
+| ---------------------------- | ------------------- | ------------------- | --------------------------------------------------- |
+| `gemini-2.5-flash-image`     | <Check size={18} /> | <Check size={18} /> | 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9 |
+| `gemini-3-pro-image-preview` | <Check size={18} /> | <Check size={18} /> | 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9 |
+
+<Note>
+  `gemini-3-pro-image-preview` supports additional features including up to 14
+  reference images for editing (6 objects, 5 humans), resolution options (1K,
+  2K, 4K via `providerOptions.google.imageConfig.imageSize`), and Google Search
+  grounding.
+</Note>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "3.0.24",
+  "version": "3.0.26",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -36,8 +36,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "3.0.8",
-    "@ai-sdk/provider-utils": "4.0.14"
+    "@ai-sdk/provider-utils": "4.0.14",
+    "@ai-sdk/provider": "3.0.8"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/google-generative-ai-embedding-model.ts

@@ -16,7 +16,7 @@ import { z } from 'zod/v4';
 import { googleFailedResponseHandler } from './google-error';
 import {
   GoogleGenerativeAIEmbeddingModelId,
-  googleGenerativeAIEmbeddingProviderOptions,
+  googleEmbeddingModelOptions,
 } from './google-generative-ai-embedding-options';
 
 type GoogleGenerativeAIEmbeddingConfig = {
@@ -57,7 +57,7 @@ export class GoogleGenerativeAIEmbeddingModel implements EmbeddingModelV3 {
     const googleOptions = await parseProviderOptions({
       provider: 'google',
       providerOptions,
-      schema: googleGenerativeAIEmbeddingProviderOptions,
+      schema: googleEmbeddingModelOptions,
     });
 
     if (values.length > this.maxEmbeddingsPerCall) {

package/src/google-generative-ai-embedding-options.ts

@@ -10,7 +10,7 @@ export type GoogleGenerativeAIEmbeddingModelId =
   | 'text-embedding-004'
   | (string & {});
 
-export const googleGenerativeAIEmbeddingProviderOptions = lazySchema(() =>
+export const googleEmbeddingModelOptions = lazySchema(() =>
   zodSchema(
     z.object({
       /**
@@ -47,6 +47,6 @@ export const googleGenerativeAIEmbeddingProviderOptions = lazySchema(() =>
   ),
 );
 
-export type GoogleGenerativeAIEmbeddingProviderOptions = InferSchema<
-  typeof googleGenerativeAIEmbeddingProviderOptions
+export type GoogleEmbeddingModelOptions = InferSchema<
+  typeof googleEmbeddingModelOptions
 >;

package/src/google-generative-ai-image-model.ts

@@ -1,11 +1,19 @@
-import { ImageModelV3, SharedV3Warning } from '@ai-sdk/provider';
+import {
+  ImageModelV3,
+  LanguageModelV3Prompt,
+  SharedV3Warning,
+} from '@ai-sdk/provider';
 import {
   combineHeaders,
+  convertToBase64,
   createJsonResponseHandler,
+  FetchFunction,
+  generateId as defaultGenerateId,
   type InferSchema,
   lazySchema,
   parseProviderOptions,
   postJsonToApi,
+  Resolvable,
   resolve,
   zodSchema,
 } from '@ai-sdk/provider-utils';
@@ -15,7 +23,7 @@ import {
   GoogleGenerativeAIImageModelId,
   GoogleGenerativeAIImageSettings,
 } from './google-generative-ai-image-settings';
-import { FetchFunction, Resolvable } from '@ai-sdk/provider-utils';
+import { GoogleGenerativeAILanguageModel } from './google-generative-ai-language-model';
 
 interface GoogleGenerativeAIImageModelConfig {
   provider: string;
@@ -32,8 +40,15 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
   readonly specificationVersion = 'v3';
 
   get maxImagesPerCall(): number {
+    if (this.settings.maxImagesPerCall != null) {
+      return this.settings.maxImagesPerCall;
+    }
+    // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/2-5-flash-image
+    if (isGeminiModel(this.modelId)) {
+      return 10;
+    }
     // https://ai.google.dev/gemini-api/docs/imagen#imagen-model
-    return this.settings.maxImagesPerCall ?? 4;
+    return 4;
   }
 
   get provider(): string {
@@ -48,6 +63,16 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
 
   async doGenerate(
     options: Parameters<ImageModelV3['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<ImageModelV3['doGenerate']>>> {
+    // Gemini image models use the language model API internally
+    if (isGeminiModel(this.modelId)) {
+      return this.doGenerateGemini(options);
+    }
+    return this.doGenerateImagen(options);
+  }
+
+  private async doGenerateImagen(
+    options: Parameters<ImageModelV3['doGenerate']>[0],
   ): Promise<Awaited<ReturnType<ImageModelV3['doGenerate']>>> {
     const {
       prompt,
@@ -63,10 +88,10 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
     } = options;
     const warnings: Array<SharedV3Warning> = [];
 
-    // Google Generative AI does not support image editing
+    // Imagen API endpoints do not support image editing
     if (files != null && files.length > 0) {
       throw new Error(
-        'Google Generative AI does not support image editing. ' +
+        'Google Generative AI does not support image editing with Imagen models. ' +
           'Use Google Vertex AI (@ai-sdk/google-vertex) for image editing capabilities.',
       );
     }
@@ -99,7 +124,7 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
     const googleOptions = await parseProviderOptions({
       provider: 'google',
       providerOptions,
-      schema: googleImageProviderOptionsSchema,
+      schema: googleImageModelOptionsSchema,
     });
 
     const currentDate = this.config._internal?.currentDate?.() ?? new Date();
@@ -138,10 +163,10 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
       images: response.predictions.map(
         (p: { bytesBase64Encoded: string }) => p.bytesBase64Encoded,
       ),
-      warnings: warnings ?? [],
+      warnings,
       providerMetadata: {
         google: {
-          images: response.predictions.map(prediction => ({
+          images: response.predictions.map(() => ({
             // Add any prediction-specific metadata here
           })),
         },
@@ -153,6 +178,146 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
       },
     };
   }
+
+  private async doGenerateGemini(
+    options: Parameters<ImageModelV3['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<ImageModelV3['doGenerate']>>> {
+    const {
+      prompt,
+      n,
+      size,
+      aspectRatio,
+      seed,
+      providerOptions,
+      headers,
+      abortSignal,
+      files,
+      mask,
+    } = options;
+    const warnings: Array<SharedV3Warning> = [];
+
+    // Gemini does not support mask-based inpainting
+    if (mask != null) {
+      throw new Error(
+        'Gemini image models do not support mask-based image editing.',
+      );
+    }
+
+    // Gemini does not support generating multiple images per call via n parameter
+    if (n != null && n > 1) {
+      throw new Error(
+        'Gemini image models do not support generating a set number of images per call. Use n=1 or omit the n parameter.',
+      );
+    }
+
+    if (size != null) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'size',
+        details:
+          'This model does not support the `size` option. Use `aspectRatio` instead.',
+      });
+    }
+
+    // Build user message content for language model
+    const userContent: Array<
+      | { type: 'text'; text: string }
+      | { type: 'file'; data: string | Uint8Array | URL; mediaType: string }
+    > = [];
+
+    // Add text prompt
+    if (prompt != null) {
+      userContent.push({ type: 'text', text: prompt });
+    }
+
+    // Add input images for editing
+    if (files != null && files.length > 0) {
+      for (const file of files) {
+        if (file.type === 'url') {
+          userContent.push({
+            type: 'file',
+            data: new URL(file.url),
+            mediaType: 'image/*',
+          });
+        } else {
+          userContent.push({
+            type: 'file',
+            data:
+              typeof file.data === 'string'
+                ? file.data
+                : new Uint8Array(file.data),
+            mediaType: file.mediaType,
+          });
+        }
+      }
+    }
+
+    const languageModelPrompt: LanguageModelV3Prompt = [
+      { role: 'user', content: userContent },
+    ];
+
+    // Instantiate language model
+    const languageModel = new GoogleGenerativeAILanguageModel(this.modelId, {
+      provider: this.config.provider,
+      baseURL: this.config.baseURL,
+      headers: this.config.headers ?? {},
+      fetch: this.config.fetch,
+      generateId: this.config.generateId ?? defaultGenerateId,
+    });
+
+    // Call language model with image-only response modality
+    const result = await languageModel.doGenerate({
+      prompt: languageModelPrompt,
+      seed,
+      providerOptions: {
+        google: {
+          responseModalities: ['IMAGE'],
+          imageConfig: aspectRatio ? { aspectRatio } : undefined,
+          ...((providerOptions?.google as Record<string, unknown>) ?? {}),
+        },
+      },
+      headers,
+      abortSignal,
+    });
+
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+
+    // Extract images from language model response
+    const images: string[] = [];
+    for (const part of result.content) {
+      if (part.type === 'file' && part.mediaType.startsWith('image/')) {
+        images.push(convertToBase64(part.data));
+      }
+    }
+
+    return {
+      images,
+      warnings,
+      providerMetadata: {
+        google: {
+          images: images.map(() => ({})),
+        },
+      },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: result.response?.headers,
+      },
+      usage: result.usage
+        ? {
+            inputTokens: result.usage.inputTokens.total,
+            outputTokens: result.usage.outputTokens.total,
+            totalTokens:
+              (result.usage.inputTokens.total ?? 0) +
+              (result.usage.outputTokens.total ?? 0),
+          }
+        : undefined,
+    };
+  }
+}
+
+function isGeminiModel(modelId: string): boolean {
+  return modelId.startsWith('gemini-');
 }
 
 // minimal version of the schema
@@ -168,7 +333,7 @@ const googleImageResponseSchema = lazySchema(() =>
 
 // Note: For the initial GA launch of Imagen 3, safety filters are not configurable.
 // https://ai.google.dev/gemini-api/docs/imagen#imagen-model
-const googleImageProviderOptionsSchema = lazySchema(() =>
+const googleImageModelOptionsSchema = lazySchema(() =>
   zodSchema(
     z.object({
       personGeneration: z
@@ -179,6 +344,6 @@ const googleImageProviderOptionsSchema = lazySchema(() =>
   ),
 );
 
-export type GoogleGenerativeAIImageProviderOptions = InferSchema<
-  typeof googleImageProviderOptionsSchema
+export type GoogleImageModelOptions = InferSchema<
+  typeof googleImageModelOptionsSchema
 >;

package/src/google-generative-ai-image-settings.ts

@@ -1,7 +1,11 @@
 export type GoogleGenerativeAIImageModelId =
+  // Imagen models (use :predict API)
   | 'imagen-4.0-generate-001'
   | 'imagen-4.0-ultra-generate-001'
   | 'imagen-4.0-fast-generate-001'
+  // Gemini image models (technically multimodal output language models, use :generateContent API)
+  | 'gemini-2.5-flash-image'
+  | 'gemini-3-pro-image-preview'
   | (string & {});
 
 export interface GoogleGenerativeAIImageSettings {

package/src/google-generative-ai-language-model.ts

@@ -36,7 +36,7 @@ import { getModelPath } from './get-model-path';
 import { googleFailedResponseHandler } from './google-error';
 import {
   GoogleGenerativeAIModelId,
-  googleGenerativeAIProviderOptions,
+  googleLanguageModelOptions,
 } from './google-generative-ai-options';
 import { GoogleGenerativeAIContentPart } from './google-generative-ai-prompt';
 import { prepareTools } from './google-prepare-tools';
@@ -103,14 +103,14 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
     let googleOptions = await parseProviderOptions({
       provider: providerOptionsName,
       providerOptions,
-      schema: googleGenerativeAIProviderOptions,
+      schema: googleLanguageModelOptions,
     });
 
     if (googleOptions == null && providerOptionsName !== 'google') {
       googleOptions = await parseProviderOptions({
         provider: 'google',
         providerOptions,
-        schema: googleGenerativeAIProviderOptions,
+        schema: googleLanguageModelOptions,
       });
     }
 

package/src/google-generative-ai-options.ts

@@ -45,7 +45,7 @@ export type GoogleGenerativeAIModelId =
   | 'gemma-3-27b-it'
   | (string & {});
 
-export const googleGenerativeAIProviderOptions = lazySchema(() =>
+export const googleLanguageModelOptions = lazySchema(() =>
   zodSchema(
     z.object({
       responseModalities: z.array(z.enum(['TEXT', 'IMAGE'])).optional(),
@@ -188,6 +188,6 @@ export const googleGenerativeAIProviderOptions = lazySchema(() =>
   ),
 );
 
-export type GoogleGenerativeAIProviderOptions = InferSchema<
-  typeof googleGenerativeAIProviderOptions
+export type GoogleLanguageModelOptions = InferSchema<
+  typeof googleLanguageModelOptions
 >;

package/src/google-generative-ai-video-model.ts

@@ -21,7 +21,7 @@ import { z } from 'zod/v4';
 import { googleFailedResponseHandler } from './google-error';
 import type { GoogleGenerativeAIVideoModelId } from './google-generative-ai-video-settings';
 
-export type GoogleGenerativeAIVideoProviderOptions = {
+export type GoogleVideoModelOptions = {
   // Polling configuration
   pollIntervalMs?: number | null;
   pollTimeoutMs?: number | null;
@@ -76,8 +76,8 @@ export class GoogleGenerativeAIVideoModel implements Experimental_VideoModelV3 {
     const googleOptions = (await parseProviderOptions({
       provider: 'google',
       providerOptions: options.providerOptions,
-      schema: googleVideoProviderOptionsSchema,
-    })) as GoogleGenerativeAIVideoProviderOptions | undefined;
+      schema: googleVideoModelOptionsSchema,
+    })) as GoogleVideoModelOptions | undefined;
 
     const instances: Array<Record<string, unknown>> = [{}];
     const instance = instances[0];
@@ -155,7 +155,7 @@ export class GoogleGenerativeAIVideoModel implements Experimental_VideoModelV3 {
     }
 
     if (googleOptions != null) {
-      const opts = googleOptions as GoogleGenerativeAIVideoProviderOptions;
+      const opts = googleOptions as GoogleVideoModelOptions;
 
       if (
         opts.personGeneration !== undefined &&
@@ -350,7 +350,7 @@ const googleOperationSchema = z.object({
     .nullish(),
 });
 
-const googleVideoProviderOptionsSchema = lazySchema(() =>
+const googleVideoModelOptionsSchema = lazySchema(() =>
   zodSchema(
     z
       .object({