@ai-sdk/google 4.0.47 → 4.0.49

package/docs/15-google.mdx

@@ -1467,7 +1467,7 @@ Function tools work the same way as on the standard provider:
 
 ```ts
 import { google } from '@ai-sdk/google';
-import { generateText, stepCountIs, tool } from 'ai';
+import { generateText, isStepCount, tool } from 'ai';
 import { z } from 'zod';
 
 const weatherTool = tool({
@@ -1479,7 +1479,7 @@ const weatherTool = tool({
 const { text, toolCalls } = await generateText({
   model: google.interactions('gemini-3.7-flash'),
   tools: { getWeather: weatherTool },
-  stopWhen: stepCountIs(5),
+  stopWhen: isStepCount(5),
   prompt: 'What is the weather in San Francisco right now?',
 });
 ```
@@ -1804,7 +1804,7 @@ import { generateText } from 'ai';
 
 const { text } = await generateText({
   model: google('gemma-3-27b-it'),
-  system: 'You are a helpful assistant that responds concisely.',
+  instructions: 'You are a helpful assistant that responds concisely.',
   prompt: 'What is machine learning?',
 });
 ```
@@ -1902,61 +1902,8 @@ The following optional provider options are available for Google embedding model
 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';
-
-const { image } = await generateImage({
-  model: google.image('imagen-4.0-generate-001'),
-  prompt: 'A futuristic cityscape at sunset',
-  aspectRatio: '16:9',
-});
-```
-
-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 { GoogleImageModelOptions } from '@ai-sdk/google';
-import { generateImage } from 'ai';
-
-const { image } = await generateImage({
-  model: google.image('imagen-4.0-generate-001'),
-  providerOptions: {
-    google: {
-      personGeneration: 'dont_allow',
-    } satisfies GoogleImageModelOptions,
-  },
-  // ...
-});
-```
-
-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`.
-
-<Note>
-  Imagen models do not support the `size` parameter. Use the `aspectRatio`
-  parameter instead.
-</Note>
-
-#### 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 |
+The `.image()` factory supports Gemini multimodal language models with image
+output capabilities through the `:generateContent` API.
 
 ### Gemini Image Models
 
@@ -2023,7 +1970,7 @@ const { image } = await generateImage({
 Gemini image models support [Google Search grounding](#google-search) through `providerOptions.google.googleSearch`. The value matches the args of `google.tools.googleSearch(...)`; pass `{}` to enable with defaults, or `{ searchTypes: { imageSearch: {} } }` to ground on reference photos.
 
 ```ts
-import { google } from '@ai-sdk/google';
+import { google, type GoogleImageModelOptions } from '@ai-sdk/google';
 import { generateImage } from 'ai';
 
 const result = await generateImage({
@@ -2033,7 +1980,7 @@ const result = await generateImage({
   providerOptions: {
     google: {
       googleSearch: { searchTypes: { imageSearch: {} } },
-    },
+    } satisfies GoogleImageModelOptions,
   },
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "4.0.47",
+  "version": "4.0.49",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/convert-json-schema-to-openapi-schema.ts

@@ -4,6 +4,16 @@ import {
   type JSONSchema7Definition,
 } from '@ai-sdk/provider';
 
+type JSONSchema7WithDefinitions = JSONSchema7 & {
+  $defs?: Record<string, JSONSchema7Definition>;
+};
+
+type ReferenceContext = {
+  definitions: Record<string, JSONSchema7Definition> | undefined;
+  dollarDefinitions: Record<string, JSONSchema7Definition> | undefined;
+  resolvingReferences: ReadonlySet<string>;
+};
+
 /**
  * Converts JSON Schema 7 to OpenAPI Schema 3.0
  */
@@ -11,26 +21,52 @@ export function convertJSONSchemaToOpenAPISchema(
   jsonSchema: JSONSchema7Definition | undefined,
   isRoot = true,
 ): unknown {
-  // Handle empty object schemas: undefined at root, preserved when nested
+  const rootSchema =
+    typeof jsonSchema === 'object'
+      ? (jsonSchema as JSONSchema7WithDefinitions)
+      : undefined;
+
+  return convertJSONSchemaDefinition(jsonSchema, isRoot, {
+    definitions: rootSchema?.definitions,
+    dollarDefinitions: rootSchema?.$defs,
+    resolvingReferences: new Set(),
+  });
+}
+
+function convertJSONSchemaDefinition(
+  jsonSchema: JSONSchema7Definition | undefined,
+  isRoot: boolean,
+  referenceContext: ReferenceContext,
+): unknown {
   if (jsonSchema == null) {
     return undefined;
   }
 
+  if (typeof jsonSchema === 'boolean') {
+    return { type: 'boolean', properties: {} };
+  }
+
+  if (jsonSchema.$ref != null) {
+    return convertJSONSchemaReference({
+      jsonSchema,
+      reference: jsonSchema.$ref,
+      isRoot,
+      referenceContext,
+    });
+  }
+
+  // Handle empty object schemas: undefined at root, preserved when nested
   if (isEmptyObjectSchema(jsonSchema)) {
     if (isRoot) {
       return undefined;
     }
 
-    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,
@@ -83,7 +119,7 @@ export function convertJSONSchemaToOpenAPISchema(
   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;
       },
       {} as Record<string, unknown>,
@@ -92,13 +128,15 @@ export function convertJSONSchemaToOpenAPISchema(
 
   if (items) {
     result.items = Array.isArray(items)
-      ? items.map(item => convertJSONSchemaToOpenAPISchema(item, false))
-      : convertJSONSchemaToOpenAPISchema(items, false);
+      ? items.map(item =>
+          convertJSONSchemaDefinition(item, false, referenceContext),
+        )
+      : convertJSONSchemaDefinition(items, false, referenceContext);
   }
 
   if (allOf) {
     result.allOf = allOf.map(item =>
-      convertJSONSchemaToOpenAPISchema(item, false),
+      convertJSONSchemaDefinition(item, false, referenceContext),
     );
   }
   if (anyOf) {
@@ -114,9 +152,10 @@ export function convertJSONSchemaToOpenAPISchema(
 
       if (nonNullSchemas.length === 1) {
         // If there's only one non-null schema, convert it and make it nullable
-        const converted = convertJSONSchemaToOpenAPISchema(
+        const converted = convertJSONSchemaDefinition(
           nonNullSchemas[0],
           false,
+          referenceContext,
         );
         if (typeof converted === 'object') {
           result.nullable = true;
@@ -125,19 +164,19 @@ export function convertJSONSchemaToOpenAPISchema(
       } else {
         // If there are multiple non-null schemas, keep them in anyOf
         result.anyOf = nonNullSchemas.map(item =>
-          convertJSONSchemaToOpenAPISchema(item, false),
+          convertJSONSchemaDefinition(item, false, referenceContext),
         );
         result.nullable = true;
       }
     } else {
       result.anyOf = anyOf.map(item =>
-        convertJSONSchemaToOpenAPISchema(item, false),
+        convertJSONSchemaDefinition(item, false, referenceContext),
       );
     }
   }
   if (oneOf) {
     result.oneOf = oneOf.map(item =>
-      convertJSONSchemaToOpenAPISchema(item, false),
+      convertJSONSchemaDefinition(item, false, referenceContext),
     );
   }
 
@@ -148,6 +187,124 @@ export function convertJSONSchemaToOpenAPISchema(
   return result;
 }
 
+function convertJSONSchemaReference({
+  jsonSchema,
+  reference,
+  isRoot,
+  referenceContext,
+}: {
+  jsonSchema: JSONSchema7;
+  reference: string;
+  isRoot: boolean;
+  referenceContext: ReferenceContext;
+}): unknown {
+  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);
+
+  // Inline references instead of emitting Google's `ref` / `defs` fields.
+  // Those fields are supported by Vertex AI's Schema representation but are
+  // rejected by the Gemini Developer API representation used by this shared
+  // converter.
+  const { $ref: _reference, ...siblingSchema } = jsonSchema;
+  const resolvedSchema =
+    typeof definition === 'boolean'
+      ? definition
+        ? siblingSchema
+        : false
+      : { ...definition, ...siblingSchema };
+
+  return convertJSONSchemaDefinition(resolvedSchema, isRoot, {
+    ...referenceContext,
+    resolvingReferences,
+  });
+}
+
+function getReferencedDefinition(
+  reference: string,
+  referenceContext: ReferenceContext,
+): {
+  definition: JSONSchema7Definition;
+  referenceKey: string;
+} {
+  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)
+    : undefined;
+
+  if (
+    source == null ||
+    encodedDefinitionName == null ||
+    encodedDefinitionName.length === 0 ||
+    encodedDefinitionName.includes('/')
+  ) {
+    throwUnsupportedReference(reference);
+  }
+
+  let decodedDefinitionName: string;
+  try {
+    decodedDefinitionName = decodeURIComponent(encodedDefinitionName);
+  } catch {
+    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: string): never {
+  throw new UnsupportedFunctionalityError({
+    functionality: `JSON Schema reference: ${reference}`,
+    message:
+      'Google schema conversion only supports references to direct children of root-level $defs or definitions.',
+  });
+}
+
 type EnumValues = NonNullable<JSONSchema7['enum']>;
 type EnumType = 'string' | 'number' | 'integer' | 'boolean';
 type GoogleEnumSchema = {

package/src/google-image-model-options.ts

@@ -1,21 +1,14 @@
-import {
-  lazySchema,
-  zodSchema,
-  type InferSchema,
-} from '@ai-sdk/provider-utils';
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
-import { googleSearchToolArgsBaseSchema } from './tool/google-search';
+import type { GoogleLanguageModelOptions } from './google-language-model-options';
+import {
+  googleSearchToolArgsBaseSchema,
+  type GoogleSearchToolArgs,
+} from './tool/google-search';
 
-// Note: For the initial GA launch of Imagen 3, safety filters are not configurable.
-// https://ai.google.dev/gemini-api/docs/imagen#imagen-model
 export const googleImageModelOptionsSchema = lazySchema(() =>
   zodSchema(
     z.object({
-      personGeneration: z
-        .enum(['dont_allow', 'allow_adult', 'allow_all'])
-        .nullish(),
-      aspectRatio: z.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
@@ -30,6 +23,9 @@ export const googleImageModelOptionsSchema = lazySchema(() =>
   ),
 );
 
-export type GoogleImageModelOptions = InferSchema<
-  typeof googleImageModelOptionsSchema
->;
+export type GoogleImageModelOptions = Omit<
+  GoogleLanguageModelOptions,
+  'responseModalities'
+> & {
+  googleSearch?: GoogleSearchToolArgs;
+};

package/src/google-image-model.ts

@@ -4,23 +4,15 @@ import type {
   SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
-  combineHeaders,
   convertToBase64,
-  createJsonResponseHandler,
   generateId as defaultGenerateId,
-  lazySchema,
   parseProviderOptions,
-  postJsonToApi,
-  resolve,
   serializeModelOptions,
   WORKFLOW_SERIALIZE,
   WORKFLOW_DESERIALIZE,
-  zodSchema,
   type FetchFunction,
   type Resolvable,
 } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
-import { googleFailedResponseHandler } from './google-error';
 import { googleImageModelOptionsSchema } from './google-image-model-options';
 import type {
   GoogleImageModelId,
@@ -61,12 +53,7 @@ export class GoogleImageModel implements ImageModelV4 {
     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 4;
+    return 10;
   }
 
   get provider(): string {
@@ -82,137 +69,12 @@ export class GoogleImageModel implements ImageModelV4 {
   async doGenerate(
     options: Parameters<ImageModelV4['doGenerate']>[0],
   ): Promise<Awaited<ReturnType<ImageModelV4['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<ImageModelV4['doGenerate']>[0],
-  ): Promise<Awaited<ReturnType<ImageModelV4['doGenerate']>>> {
-    const {
-      prompt,
-      n = 1,
-      size,
-      aspectRatio = '1:1',
-      seed,
-      providerOptions,
-      headers,
-      abortSignal,
-      files,
-      mask,
-    } = options;
-    const warnings: Array<SharedV4Warning> = [];
-
-    // Imagen API endpoints do not support image editing
-    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) {
+    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 parseProviderOptions({
-      provider: 'google',
-      providerOptions,
-      schema: googleImageModelOptionsSchema,
-    });
-
-    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
-
-    const parameters: Record<string, unknown> = {
-      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 postJsonToApi<{
-      predictions: Array<{ bytesBase64Encoded: string }>;
-    }>({
-      url: `${this.config.baseURL}/models/${this.modelId}:predict`,
-      headers: combineHeaders(
-        this.config.headers ? await resolve(this.config.headers) : undefined,
-        headers,
-      ),
-      body,
-      failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        googleImageResponseSchema,
-      ),
-      abortSignal,
-      fetch: this.config.fetch,
-    });
-    return {
-      images: response.predictions.map(
-        (p: { bytesBase64Encoded: string }) => p.bytesBase64Encoded,
-      ),
-      warnings,
-      providerMetadata: {
-        google: {
-          images: response.predictions.map(() => ({
-            // Add any prediction-specific metadata here
-          })),
-        },
-      },
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders,
-      },
-    };
-  }
-
-  private async doGenerateGemini(
-    options: Parameters<ImageModelV4['doGenerate']>[0],
-  ): Promise<Awaited<ReturnType<ImageModelV4['doGenerate']>>> {
     const {
       prompt,
       n,
@@ -302,8 +164,12 @@ export class GoogleImageModel implements ImageModelV4 {
       schema: googleImageModelOptionsSchema,
     });
 
-    const { googleSearch: _strippedGoogleSearch, ...passthroughGoogleOptions } =
-      providerOptions?.google ?? {};
+    const {
+      googleSearch: _strippedGoogleSearch,
+      responseModalities: _strippedResponseModalities,
+      imageConfig: userImageConfig,
+      ...passthroughGoogleOptions
+    } = providerOptions?.google ?? {};
 
     // Instantiate language model
     const languageModel = new GoogleLanguageModel(this.modelId, {
@@ -320,18 +186,26 @@ export class GoogleImageModel implements ImageModelV4 {
       seed,
       providerOptions: {
         google: {
-          responseModalities: ['IMAGE'],
-          imageConfig: aspectRatio
-            ? {
-                aspectRatio: aspectRatio as NonNullable<
-                  GoogleLanguageModelOptions['imageConfig']
-                >['aspectRatio'],
-              }
-            : undefined,
           ...(passthroughGoogleOptions as Omit<
             GoogleLanguageModelOptions,
             'responseModalities' | 'imageConfig'
           >),
+          responseModalities: ['IMAGE'],
+          imageConfig:
+            aspectRatio != null || userImageConfig != null
+              ? {
+                  ...(userImageConfig as NonNullable<
+                    GoogleLanguageModelOptions['imageConfig']
+                  >),
+                  ...(aspectRatio != null
+                    ? {
+                        aspectRatio: aspectRatio as NonNullable<
+                          GoogleLanguageModelOptions['imageConfig']
+                        >['aspectRatio'],
+                      }
+                    : {}),
+                }
+              : undefined,
         } satisfies GoogleLanguageModelOptions,
       },
       tools:
@@ -393,18 +267,3 @@ export class GoogleImageModel implements ImageModelV4 {
     };
   }
 }
-
-function isGeminiModel(modelId: string): boolean {
-  return modelId.startsWith('gemini-');
-}
-
-// minimal version of the schema
-const googleImageResponseSchema = lazySchema(() =>
-  zodSchema(
-    z.object({
-      predictions: z
-        .array(z.object({ bytesBase64Encoded: z.string() }))
-        .default([]),
-    }),
-  ),
-);

package/src/google-image-settings.ts

@@ -1,8 +1,4 @@
 export type GoogleImageModelId =
-  // 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'
@@ -11,7 +7,7 @@ export type GoogleImageModelId =
 
 export interface GoogleImageSettings {
   /**
-   * Override the maximum number of images per call (default 4)
+   * Override the maximum number of images per call (default 10)
    */
   maxImagesPerCall?: number;
 }