@ai-sdk/google 4.0.0-beta.21 → 4.0.0-beta.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "4.0.0-beta.21",
+  "version": "4.0.0-beta.23",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -36,8 +36,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.0-beta.5",
-    "@ai-sdk/provider-utils": "5.0.0-beta.9"
+    "@ai-sdk/provider": "4.0.0-beta.6",
+    "@ai-sdk/provider-utils": "5.0.0-beta.10"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/convert-to-google-generative-ai-messages.ts

@@ -2,7 +2,11 @@ import {
   LanguageModelV4Prompt,
   UnsupportedFunctionalityError,
 } from '@ai-sdk/provider';
-import { convertToBase64 } from '@ai-sdk/provider-utils';
+import {
+  convertToBase64,
+  isProviderReference,
+  resolveProviderReference,
+} from '@ai-sdk/provider-utils';
 import {
   GoogleGenerativeAIContent,
   GoogleGenerativeAIContentPart,
@@ -203,25 +207,40 @@ export function convertToGoogleGenerativeAIMessages(
             }
 
             case 'file': {
-              // default to image/jpeg for unknown image/* types
               const mediaType =
                 part.mediaType === 'image/*' ? 'image/jpeg' : part.mediaType;
 
-              parts.push(
-                part.data instanceof URL
-                  ? {
-                      fileData: {
-                        mimeType: mediaType,
-                        fileUri: part.data.toString(),
-                      },
-                    }
-                  : {
-                      inlineData: {
-                        mimeType: mediaType,
-                        data: convertToBase64(part.data),
-                      },
-                    },
-              );
+              if (part.data instanceof URL) {
+                parts.push({
+                  fileData: {
+                    mimeType: mediaType,
+                    fileUri: part.data.toString(),
+                  },
+                });
+              } else if (isProviderReference(part.data)) {
+                if (providerOptionsName === 'vertex') {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: 'file parts with provider references',
+                  });
+                }
+
+                parts.push({
+                  fileData: {
+                    mimeType: mediaType,
+                    fileUri: resolveProviderReference({
+                      reference: part.data,
+                      provider: 'google',
+                    }),
+                  },
+                });
+              } else {
+                parts.push({
+                  inlineData: {
+                    mimeType: mediaType,
+                    data: convertToBase64(part.data),
+                  },
+                });
+              }
 
               break;
             }
@@ -295,6 +314,28 @@ export function convertToGoogleGenerativeAIMessages(
                     });
                   }
 
+                  if (isProviderReference(part.data)) {
+                    if (providerOptionsName === 'vertex') {
+                      throw new UnsupportedFunctionalityError({
+                        functionality: 'file parts with provider references',
+                      });
+                    }
+
+                    return {
+                      fileData: {
+                        mimeType: part.mediaType,
+                        fileUri: resolveProviderReference({
+                          reference: part.data,
+                          provider: 'google',
+                        }),
+                      },
+                      ...(providerOpts?.thought === true
+                        ? { thought: true }
+                        : {}),
+                      thoughtSignature,
+                    };
+                  }
+
                   return {
                     inlineData: {
                       mimeType: part.mediaType,

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

@@ -0,0 +1,230 @@
+import {
+  AISDKError,
+  type FilesV4,
+  type FilesV4UploadFileCallOptions,
+  type FilesV4UploadFileResult,
+  type SharedV4Warning,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler,
+  delay,
+  type FetchFunction,
+  lazySchema,
+  parseProviderOptions,
+  postJsonToApi,
+  zodSchema,
+  getFromApi,
+} 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 GoogleGenerativeAIFilesConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+}
+
+export class GoogleGenerativeAIFiles implements FilesV4 {
+  readonly specificationVersion = 'v4';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(private readonly config: GoogleGenerativeAIFilesConfig) {}
+
+  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 data = options.data;
+    const fileBytes =
+      data instanceof Uint8Array
+        ? data
+        : Uint8Array.from(atob(data), c => c.charCodeAt(0));
+
+    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-generative-ai-prompt.ts

@@ -22,7 +22,11 @@ export type GoogleGenerativeAIContent = {
 
 export type GoogleGenerativeAIContentPart =
   | { text: string; thought?: boolean; thoughtSignature?: string }
-  | { inlineData: { mimeType: string; data: string } }
+  | {
+      inlineData: { mimeType: string; data: string };
+      thought?: boolean;
+      thoughtSignature?: string;
+    }
   | { functionCall: { name: string; args: unknown }; thoughtSignature?: string }
   | {
       functionResponse: {
@@ -31,7 +35,11 @@ export type GoogleGenerativeAIContentPart =
         parts?: Array<GoogleGenerativeAIFunctionResponsePart>;
       };
     }
-  | { fileData: { mimeType: string; fileUri: string } }
+  | {
+      fileData: { mimeType: string; fileUri: string };
+      thought?: boolean;
+      thoughtSignature?: string;
+    }
   | {
       toolCall: {
         toolType: string;

package/src/google-provider.ts

@@ -1,6 +1,7 @@
 import {
   EmbeddingModelV4,
   Experimental_VideoModelV4,
+  FilesV4,
   ImageModelV4,
   LanguageModelV4,
   ProviderV4,
@@ -24,6 +25,7 @@ import {
   GoogleGenerativeAIImageModelId,
 } from './google-generative-ai-image-settings';
 import { GoogleGenerativeAIImageModel } from './google-generative-ai-image-model';
+import { GoogleGenerativeAIFiles } from './google-generative-ai-files';
 import { GoogleGenerativeAIVideoModel } from './google-generative-ai-video-model';
 import { GoogleGenerativeAIVideoModelId } from './google-generative-ai-video-settings';
 
@@ -81,6 +83,8 @@ export interface GoogleGenerativeAIProvider extends ProviderV4 {
     modelId: GoogleGenerativeAIVideoModelId,
   ): Experimental_VideoModelV4;
 
+  files(): FilesV4;
+
   tools: typeof googleTools;
 }
 
@@ -185,6 +189,14 @@ export function createGoogleGenerativeAI(
       fetch: options.fetch,
     });
 
+  const createFiles = () =>
+    new GoogleGenerativeAIFiles({
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
   const createVideoModel = (modelId: GoogleGenerativeAIVideoModelId) =>
     new GoogleGenerativeAIVideoModel(modelId, {
       provider: providerName,
@@ -216,6 +228,7 @@ export function createGoogleGenerativeAI(
   provider.imageModel = createImageModel;
   provider.video = createVideoModel;
   provider.videoModel = createVideoModel;
+  provider.files = createFiles;
   provider.tools = googleTools;
 
   return provider as GoogleGenerativeAIProvider;

package/src/index.ts

@@ -21,6 +21,7 @@ export type {
   GoogleVideoModelOptions as GoogleGenerativeAIVideoProviderOptions,
 } from './google-generative-ai-video-model';
 export type { GoogleGenerativeAIVideoModelId } from './google-generative-ai-video-settings';
+export type { GoogleFilesUploadOptions } from './google-generative-ai-files';
 export { createGoogleGenerativeAI, google } from './google-provider';
 export type {
   GoogleGenerativeAIProvider,