@ai-sdk/google-vertex 4.0.55 → 4.0.57

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

@@ -1,13 +1,18 @@
+import type { GoogleLanguageModelOptions } from '@ai-sdk/google';
+import { GoogleGenerativeAILanguageModel } from '@ai-sdk/google/internal';
 import {
   ImageModelV3,
   ImageModelV3File,
+  LanguageModelV3Prompt,
   SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
   Resolvable,
   combineHeaders,
+  convertToBase64,
   convertUint8ArrayToBase64,
   createJsonResponseHandler,
+  generateId as defaultGenerateId,
   parseProviderOptions,
   postJsonToApi,
   resolve,
@@ -21,6 +26,7 @@ interface GoogleVertexImageModelConfig {
   baseURL: string;
   headers?: Resolvable<Record<string, string | undefined>>;
   fetch?: typeof fetch;
+  generateId?: () => string;
   _internal?: {
     currentDate?: () => Date;
   };
@@ -29,8 +35,13 @@ interface GoogleVertexImageModelConfig {
 // https://cloud.google.com/vertex-ai/generative-ai/docs/image/generate-images
 export class GoogleVertexImageModel implements ImageModelV3 {
   readonly specificationVersion = 'v3';
-  // https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/imagen-api#parameter_list
-  readonly maxImagesPerCall = 4;
+
+  get maxImagesPerCall(): number {
+    if (isGeminiModel(this.modelId)) {
+      return 10;
+    }
+    return 4;
+  }
 
   get provider(): string {
     return this.config.provider;
@@ -41,7 +52,16 @@ export class GoogleVertexImageModel implements ImageModelV3 {
     private config: GoogleVertexImageModelConfig,
   ) {}
 
-  async doGenerate({
+  async doGenerate(
+    options: Parameters<ImageModelV3['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<ImageModelV3['doGenerate']>>> {
+    if (isGeminiModel(this.modelId)) {
+      return this.doGenerateGemini(options);
+    }
+    return this.doGenerateImagen(options);
+  }
+
+  private async doGenerateImagen({
     prompt,
     n,
     size,
@@ -180,6 +200,149 @@ export class GoogleVertexImageModel implements ImageModelV3 {
       },
     };
   }
+
+  private async doGenerateGemini({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    providerOptions,
+    headers,
+    abortSignal,
+    files,
+    mask,
+  }: Parameters<ImageModelV3['doGenerate']>[0]): Promise<
+    Awaited<ReturnType<ImageModelV3['doGenerate']>>
+  > {
+    const warnings: Array<SharedV3Warning> = [];
+
+    if (mask != null) {
+      throw new Error(
+        'Gemini image models do not support mask-based image editing.',
+      );
+    }
+
+    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.',
+      });
+    }
+
+    const userContent: Array<
+      | { type: 'text'; text: string }
+      | { type: 'file'; data: string | Uint8Array | URL; mediaType: string }
+    > = [];
+
+    if (prompt != null) {
+      userContent.push({ type: 'text', text: prompt });
+    }
+
+    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 },
+    ];
+
+    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,
+      supportedUrls: () => ({
+        '*': [/^https?:\/\/.*$/, /^gs:\/\/.*$/],
+      }),
+    });
+
+    const result = await languageModel.doGenerate({
+      prompt: languageModelPrompt,
+      seed,
+      providerOptions: {
+        vertex: {
+          responseModalities: ['IMAGE'],
+          imageConfig: aspectRatio
+            ? {
+                aspectRatio: aspectRatio as NonNullable<
+                  GoogleLanguageModelOptions['imageConfig']
+                >['aspectRatio'],
+              }
+            : undefined,
+          ...((providerOptions?.vertex as Omit<
+            GoogleLanguageModelOptions,
+            'responseModalities' | 'imageConfig'
+          >) ?? {}),
+        } satisfies GoogleLanguageModelOptions,
+      },
+      headers,
+      abortSignal,
+    });
+
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+
+    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: {
+        vertex: {
+          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, focussed on what is needed for the implementation

package/src/google-vertex-image-settings.ts

@@ -5,4 +5,6 @@ export type GoogleVertexImageModelId =
   | 'imagen-4.0-generate-001'
   | 'imagen-4.0-ultra-generate-001'
   | 'imagen-4.0-fast-generate-001'
+  | 'gemini-2.5-flash-image'
+  | 'gemini-3-pro-image-preview'
   | (string & {});

package/src/google-vertex-provider.ts

@@ -210,7 +210,10 @@ export function createVertex(
     new GoogleVertexEmbeddingModel(modelId, createConfig('embedding'));
 
   const createImageModel = (modelId: GoogleVertexImageModelId) =>
-    new GoogleVertexImageModel(modelId, createConfig('image'));
+    new GoogleVertexImageModel(modelId, {
+      ...createConfig('image'),
+      generateId: options.generateId ?? generateId,
+    });
 
   const createVideoModel = (modelId: GoogleVertexVideoModelId) =>
     new GoogleVertexVideoModel(modelId, {