@ai-sdk/google 4.0.0-beta.8 → 4.0.0-canary.50

package/src/google-files.ts

@@ -0,0 +1,225 @@
+import {
+  AISDKError,
+  type FilesV4,
+  type FilesV4UploadFileCallOptions,
+  type FilesV4UploadFileResult,
+  type SharedV4Warning,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertInlineFileDataToUint8Array,
+  createJsonResponseHandler,
+  delay,
+  lazySchema,
+  parseProviderOptions,
+  zodSchema,
+  getFromApi,
+  type FetchFunction,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { googleFailedResponseHandler } from './google-error';
+
+export type GoogleFilesUploadOptions = {
+  displayName?: string | null;
+  pollIntervalMs?: number | null;
+  pollTimeoutMs?: number | null;
+
+  [key: string]: unknown;
+};
+
+interface GoogleFilesConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+}
+
+export class GoogleFiles implements FilesV4 {
+  readonly specificationVersion = 'v4';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(private readonly config: GoogleFilesConfig) {}
+
+  async uploadFile(
+    options: FilesV4UploadFileCallOptions,
+  ): Promise<FilesV4UploadFileResult> {
+    const googleOptions = (await parseProviderOptions({
+      provider: 'google',
+      providerOptions: options.providerOptions,
+      schema: googleFilesUploadOptionsSchema,
+    })) as GoogleFilesUploadOptions | undefined;
+
+    const resolvedHeaders = this.config.headers();
+    const fetchFn = this.config.fetch ?? globalThis.fetch;
+
+    const warnings: Array<SharedV4Warning> = [];
+    if (options.filename != null) {
+      warnings.push({ type: 'unsupported', feature: 'filename' });
+    }
+
+    const fileBytes = convertInlineFileDataToUint8Array(options.data);
+
+    const mediaType = options.mediaType;
+    const displayName = googleOptions?.displayName;
+
+    const baseOrigin = this.config.baseURL.replace(/\/v1beta$/, '');
+
+    const initResponse = await fetchFn(`${baseOrigin}/upload/v1beta/files`, {
+      method: 'POST',
+      headers: {
+        ...resolvedHeaders,
+        'X-Goog-Upload-Protocol': 'resumable',
+        'X-Goog-Upload-Command': 'start',
+        'X-Goog-Upload-Header-Content-Length': String(fileBytes.length),
+        'X-Goog-Upload-Header-Content-Type': mediaType,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        file: {
+          ...(displayName != null ? { display_name: displayName } : {}),
+        },
+      }),
+    });
+
+    if (!initResponse.ok) {
+      const errorBody = await initResponse.text();
+      throw new AISDKError({
+        name: 'GOOGLE_FILES_UPLOAD_ERROR',
+        message: `Failed to initiate resumable upload: ${initResponse.status} ${errorBody}`,
+      });
+    }
+
+    const uploadUrl = initResponse.headers.get('x-goog-upload-url');
+    if (!uploadUrl) {
+      throw new AISDKError({
+        name: 'GOOGLE_FILES_UPLOAD_ERROR',
+        message: 'No upload URL returned from initiation request',
+      });
+    }
+
+    const uploadResponse = await fetchFn(uploadUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Length': String(fileBytes.length),
+        'X-Goog-Upload-Offset': '0',
+        'X-Goog-Upload-Command': 'upload, finalize',
+      },
+      body: fileBytes,
+    });
+
+    if (!uploadResponse.ok) {
+      const errorBody = await uploadResponse.text();
+      throw new AISDKError({
+        name: 'GOOGLE_FILES_UPLOAD_ERROR',
+        message: `Failed to upload file data: ${uploadResponse.status} ${errorBody}`,
+      });
+    }
+
+    const uploadResult = (await uploadResponse.json()) as {
+      file: GoogleFileResource;
+    };
+
+    let file = uploadResult.file;
+
+    const pollIntervalMs = googleOptions?.pollIntervalMs ?? 2000;
+    const pollTimeoutMs = googleOptions?.pollTimeoutMs ?? 300000;
+    const startTime = Date.now();
+
+    while (file.state === 'PROCESSING') {
+      if (Date.now() - startTime > pollTimeoutMs) {
+        throw new AISDKError({
+          name: 'GOOGLE_FILES_UPLOAD_TIMEOUT',
+          message: `File processing timed out after ${pollTimeoutMs}ms`,
+        });
+      }
+
+      await delay(pollIntervalMs);
+
+      const { value: fileStatus } = await getFromApi({
+        url: `${this.config.baseURL}/${file.name}`,
+        headers: combineHeaders(resolvedHeaders),
+        successfulResponseHandler: createJsonResponseHandler(
+          googleFileResponseSchema,
+        ),
+        failedResponseHandler: googleFailedResponseHandler,
+        fetch: this.config.fetch,
+      });
+
+      file = fileStatus;
+    }
+
+    if (file.state === 'FAILED') {
+      throw new AISDKError({
+        name: 'GOOGLE_FILES_UPLOAD_FAILED',
+        message: `File processing failed for ${file.name}`,
+      });
+    }
+
+    return {
+      warnings,
+      providerReference: { google: file.uri },
+      mediaType: file.mimeType ?? options.mediaType,
+      providerMetadata: {
+        google: {
+          name: file.name,
+          displayName: file.displayName,
+          mimeType: file.mimeType,
+          sizeBytes: file.sizeBytes,
+          state: file.state,
+          uri: file.uri,
+          ...(file.createTime != null ? { createTime: file.createTime } : {}),
+          ...(file.updateTime != null ? { updateTime: file.updateTime } : {}),
+          ...(file.expirationTime != null
+            ? { expirationTime: file.expirationTime }
+            : {}),
+          ...(file.sha256Hash != null ? { sha256Hash: file.sha256Hash } : {}),
+        },
+      },
+    };
+  }
+}
+
+type GoogleFileResource = {
+  name: string;
+  displayName?: string | null;
+  mimeType: string;
+  sizeBytes?: string | null;
+  createTime?: string | null;
+  updateTime?: string | null;
+  expirationTime?: string | null;
+  sha256Hash?: string | null;
+  uri: string;
+  state: string;
+};
+
+const googleFileResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      name: z.string(),
+      displayName: z.string().nullish(),
+      mimeType: z.string(),
+      sizeBytes: z.string().nullish(),
+      createTime: z.string().nullish(),
+      updateTime: z.string().nullish(),
+      expirationTime: z.string().nullish(),
+      sha256Hash: z.string().nullish(),
+      uri: z.string(),
+      state: z.string(),
+    }),
+  ),
+);
+
+const googleFilesUploadOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        displayName: z.string().nullish(),
+        pollIntervalMs: z.number().positive().nullish(),
+        pollTimeoutMs: z.number().positive().nullish(),
+      })
+      .passthrough(),
+  ),
+);

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

@@ -0,0 +1,23 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+// 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(),
+    }),
+  ),
+);
+
+export type GoogleImageModelOptions = InferSchema<
+  typeof googleImageModelOptionsSchema
+>;

package/src/{google-generative-ai-image-model.ts → google-image-model.ts}

@@ -1,32 +1,35 @@
-import {
-  ImageModelV3,
-  LanguageModelV3Prompt,
-  SharedV3Warning,
+import type {
+  ImageModelV4,
+  LanguageModelV4Prompt,
+  SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   convertToBase64,
   createJsonResponseHandler,
-  FetchFunction,
   generateId as defaultGenerateId,
-  type InferSchema,
   lazySchema,
   parseProviderOptions,
   postJsonToApi,
-  Resolvable,
   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 {
-  GoogleGenerativeAIImageModelId,
-  GoogleGenerativeAIImageSettings,
-} from './google-generative-ai-image-settings';
-import { GoogleGenerativeAILanguageModel } from './google-generative-ai-language-model';
-import type { GoogleLanguageModelOptions } from './google-generative-ai-options';
-
-interface GoogleGenerativeAIImageModelConfig {
+import { googleImageModelOptionsSchema } from './google-image-model-options';
+import type {
+  GoogleImageModelId,
+  GoogleImageSettings,
+} from './google-image-settings';
+import { GoogleLanguageModel } from './google-language-model';
+import type { GoogleLanguageModelOptions } from './google-language-model-options';
+
+interface GoogleImageModelConfig {
   provider: string;
   baseURL: string;
   headers?: Resolvable<Record<string, string | undefined>>;
@@ -37,8 +40,22 @@ interface GoogleGenerativeAIImageModelConfig {
   };
 }
 
-export class GoogleGenerativeAIImageModel implements ImageModelV3 {
-  readonly specificationVersion = 'v3';
+export class GoogleImageModel implements ImageModelV4 {
+  readonly specificationVersion = 'v4';
+
+  static [WORKFLOW_SERIALIZE](model: GoogleImageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: string;
+    config: GoogleImageModelConfig;
+  }) {
+    return new GoogleImageModel(options.modelId, {}, options.config);
+  }
 
   get maxImagesPerCall(): number {
     if (this.settings.maxImagesPerCall != null) {
@@ -57,14 +74,14 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
   }
 
   constructor(
-    readonly modelId: GoogleGenerativeAIImageModelId,
-    private readonly settings: GoogleGenerativeAIImageSettings,
-    private readonly config: GoogleGenerativeAIImageModelConfig,
+    readonly modelId: GoogleImageModelId,
+    private readonly settings: GoogleImageSettings,
+    private readonly config: GoogleImageModelConfig,
   ) {}
 
   async doGenerate(
-    options: Parameters<ImageModelV3['doGenerate']>[0],
-  ): Promise<Awaited<ReturnType<ImageModelV3['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);
@@ -73,8 +90,8 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
   }
 
   private async doGenerateImagen(
-    options: Parameters<ImageModelV3['doGenerate']>[0],
-  ): Promise<Awaited<ReturnType<ImageModelV3['doGenerate']>>> {
+    options: Parameters<ImageModelV4['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<ImageModelV4['doGenerate']>>> {
     const {
       prompt,
       n = 1,
@@ -87,19 +104,19 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
       files,
       mask,
     } = options;
-    const warnings: Array<SharedV3Warning> = [];
+    const warnings: Array<SharedV4Warning> = [];
 
     // 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 with Imagen models. ' +
+        '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) {
       throw new Error(
-        'Google Generative AI does not support image editing with masks. ' +
+        'Google Gemini API does not support image editing with masks. ' +
           'Use Google Vertex AI (@ai-sdk/google-vertex) for image editing capabilities.',
       );
     }
@@ -151,7 +168,10 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
       predictions: Array<{ bytesBase64Encoded: string }>;
     }>({
       url: `${this.config.baseURL}/models/${this.modelId}:predict`,
-      headers: combineHeaders(await resolve(this.config.headers), headers),
+      headers: combineHeaders(
+        this.config.headers ? await resolve(this.config.headers) : undefined,
+        headers,
+      ),
       body,
       failedResponseHandler: googleFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
@@ -181,8 +201,8 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
   }
 
   private async doGenerateGemini(
-    options: Parameters<ImageModelV3['doGenerate']>[0],
-  ): Promise<Awaited<ReturnType<ImageModelV3['doGenerate']>>> {
+    options: Parameters<ImageModelV4['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<ImageModelV4['doGenerate']>>> {
     const {
       prompt,
       n,
@@ -195,7 +215,7 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
       files,
       mask,
     } = options;
-    const warnings: Array<SharedV3Warning> = [];
+    const warnings: Array<SharedV4Warning> = [];
 
     // Gemini does not support mask-based inpainting
     if (mask != null) {
@@ -220,45 +240,51 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
       });
     }
 
-    // Build user message content for language model
     const userContent: Array<
       | { type: 'text'; text: string }
-      | { type: 'file'; data: string | Uint8Array | URL; mediaType: string }
+      | {
+          type: 'file';
+          data:
+            | { type: 'data'; data: string | Uint8Array }
+            | { type: 'url'; url: 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),
+            data: { type: 'url', url: new URL(file.url) },
             mediaType: 'image/*',
           });
         } else {
           userContent.push({
             type: 'file',
-            data:
-              typeof file.data === 'string'
-                ? file.data
-                : new Uint8Array(file.data),
+            data: {
+              type: 'data',
+              data:
+                typeof file.data === 'string'
+                  ? file.data
+                  : new Uint8Array(file.data),
+            },
             mediaType: file.mediaType,
           });
         }
       }
     }
 
-    const languageModelPrompt: LanguageModelV3Prompt = [
+    const languageModelPrompt: LanguageModelV4Prompt = [
       { role: 'user', content: userContent },
     ];
 
     // Instantiate language model
-    const languageModel = new GoogleGenerativeAILanguageModel(this.modelId, {
+    const languageModel = new GoogleLanguageModel(this.modelId, {
       provider: this.config.provider,
       baseURL: this.config.baseURL,
       headers: this.config.headers ?? {},
@@ -292,11 +318,14 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
 
     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));
+      if (
+        part.type === 'file' &&
+        part.mediaType.startsWith('image/') &&
+        part.data.type === 'data'
+      ) {
+        images.push(convertToBase64(part.data.data));
       }
     }
 
@@ -340,20 +369,3 @@ 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 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(),
-    }),
-  ),
-);
-
-export type GoogleImageModelOptions = InferSchema<
-  typeof googleImageModelOptionsSchema
->;

package/src/{google-generative-ai-image-settings.ts → google-image-settings.ts}

@@ -1,4 +1,4 @@
-export type GoogleGenerativeAIImageModelId =
+export type GoogleImageModelId =
   // Imagen models (use :predict API)
   | 'imagen-4.0-generate-001'
   | 'imagen-4.0-ultra-generate-001'
@@ -9,7 +9,7 @@ export type GoogleGenerativeAIImageModelId =
   | 'gemini-3.1-flash-image-preview'
   | (string & {});
 
-export interface GoogleGenerativeAIImageSettings {
+export interface GoogleImageSettings {
   /**
    * Override the maximum number of images per call (default 4)
    */