@ai-sdk/google-vertex 5.0.0-beta.62 → 5.0.0-beta.63

package/src/anthropic/google-vertex-anthropic-provider.ts

@@ -19,7 +19,7 @@ import type { GoogleVertexAnthropicModelId } from './google-vertex-anthropic-opt
  * Tools supported by Google Vertex Anthropic.
  * This is a subset of the full Anthropic tools - only these are recognized by the Vertex API.
  */
-export const vertexAnthropicTools = {
+export const googleVertexAnthropicTools = {
   /**
    * The bash tool enables Claude to execute shell commands in a persistent bash session,
    * allowing system operations, script execution, and command-line automation.
@@ -120,7 +120,7 @@ export interface GoogleVertexAnthropicProvider extends ProviderV4 {
    * computer_20241022, webSearch_20250305, toolSearchRegex_20251119,
    * toolSearchBm25_20251119
    */
-  tools: typeof vertexAnthropicTools;
+  tools: typeof googleVertexAnthropicTools;
 
   /**
    * @deprecated Use `embeddingModel` instead.
@@ -160,7 +160,7 @@ export interface GoogleVertexAnthropicProviderSettings {
 /**
  * Create a Google Vertex Anthropic provider instance.
  */
-export function createVertexAnthropic(
+export function createGoogleVertexAnthropic(
   options: GoogleVertexAnthropicProviderSettings = {},
 ): GoogleVertexAnthropicProvider {
   const getBaseURL = () => {
@@ -181,7 +181,7 @@ export function createVertexAnthropic(
 
   const createChatModel = (modelId: GoogleVertexAnthropicModelId) =>
     new AnthropicLanguageModel(modelId, {
-      provider: 'vertex.anthropic.messages',
+      provider: 'googleVertex.anthropic.messages',
       baseURL: getBaseURL(),
       headers: options.headers ?? {},
       fetch: options.fetch,
@@ -229,7 +229,7 @@ export function createVertexAnthropic(
     throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
   };
 
-  provider.tools = vertexAnthropicTools;
+  provider.tools = googleVertexAnthropicTools;
 
   return provider;
 }

package/src/anthropic/index.ts

@@ -1,6 +1,10 @@
 export {
-  vertexAnthropic,
-  createVertexAnthropic,
+  googleVertexAnthropic,
+  /** @deprecated Use `googleVertexAnthropic` instead. */
+  googleVertexAnthropic as vertexAnthropic,
+  createGoogleVertexAnthropic,
+  /** @deprecated Use `createGoogleVertexAnthropic` instead. */
+  createGoogleVertexAnthropic as createVertexAnthropic,
 } from './google-vertex-anthropic-provider-node';
 export type {
   GoogleVertexAnthropicProvider,

package/src/edge/google-vertex-provider-edge.ts

@@ -1,9 +1,9 @@
 import { loadOptionalSetting, resolve } from '@ai-sdk/provider-utils';
 import {
-  createVertex as createVertexOriginal,
+  createGoogleVertex as createGoogleVertexOriginal,
   type GoogleVertexProvider,
   type GoogleVertexProviderSettings as GoogleVertexProviderSettingsOriginal,
-} from '../google-vertex-provider';
+} from '../google-vertex-provider-base';
 import {
   generateAuthToken,
   type GoogleCredentials,
@@ -19,7 +19,7 @@ export interface GoogleVertexProviderSettings extends GoogleVertexProviderSettin
   googleCredentials?: GoogleCredentials;
 }
 
-export function createVertex(
+export function createGoogleVertex(
   options: GoogleVertexProviderSettings = {},
 ): GoogleVertexProvider {
   const apiKey = loadOptionalSetting({
@@ -28,10 +28,10 @@ export function createVertex(
   });
 
   if (apiKey) {
-    return createVertexOriginal(options);
+    return createGoogleVertexOriginal(options);
   }
 
-  return createVertexOriginal({
+  return createGoogleVertexOriginal({
     ...options,
     headers: async () => ({
       Authorization: `Bearer ${await generateAuthToken(
@@ -45,4 +45,4 @@ export function createVertex(
 /**
  * Default Google Vertex AI provider instance.
  */
-export const vertex = createVertex();
+export const googleVertex = createGoogleVertex();

package/src/edge/index.ts

@@ -1,4 +1,11 @@
-export { createVertex, vertex } from './google-vertex-provider-edge';
+export {
+  createGoogleVertex,
+  /** @deprecated Use `createGoogleVertex` instead. */
+  createGoogleVertex as createVertex,
+  googleVertex,
+  /** @deprecated Use `googleVertex` instead. */
+  googleVertex as vertex,
+} from './google-vertex-provider-edge';
 export type {
   GoogleVertexProviderSettings,
   GoogleVertexProvider,

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

@@ -17,7 +17,7 @@ import { googleVertexFailedResponseHandler } from './google-vertex-error';
 import {
   googleVertexEmbeddingModelOptions,
   type GoogleVertexEmbeddingModelId,
-} from './google-vertex-embedding-options';
+} from './google-vertex-embedding-model-options';
 import type { GoogleVertexConfig } from './google-vertex-config';
 
 export class GoogleVertexEmbeddingModel implements EmbeddingModelV4 {
@@ -63,11 +63,19 @@ export class GoogleVertexEmbeddingModel implements EmbeddingModelV4 {
     Awaited<ReturnType<EmbeddingModelV4['doEmbed']>>
   > {
     let googleOptions = await parseProviderOptions({
-      provider: 'vertex',
+      provider: 'googleVertex',
       providerOptions,
       schema: googleVertexEmbeddingModelOptions,
     });
 
+    if (googleOptions == null) {
+      googleOptions = await parseProviderOptions({
+        provider: 'vertex',
+        providerOptions,
+        schema: googleVertexEmbeddingModelOptions,
+      });
+    }
+
     if (googleOptions == null) {
       googleOptions = await parseProviderOptions({
         provider: 'google',

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

@@ -0,0 +1,74 @@
+import { z } from 'zod/v4';
+
+export const googleVertexImageModelOptionsSchema = z.object({
+  negativePrompt: z.string().nullish(),
+  personGeneration: z
+    .enum(['dont_allow', 'allow_adult', 'allow_all'])
+    .nullish(),
+  safetySetting: z
+    .enum([
+      'block_low_and_above',
+      'block_medium_and_above',
+      'block_only_high',
+      'block_none',
+    ])
+    .nullish(),
+  addWatermark: z.boolean().nullish(),
+  storageUri: z.string().nullish(),
+  sampleImageSize: z.enum(['1K', '2K']).nullish(),
+  /**
+   * Configuration for image editing operations
+   */
+  edit: z
+    .object({
+      /**
+       * An integer that represents the number of sampling steps.
+       * A higher value offers better image quality, a lower value offers better latency.
+       * Try 35 steps to start. If the quality doesn't meet your requirements,
+       * increase the value towards an upper limit of 75.
+       */
+      baseSteps: z.number().nullish(),
+
+      // Edit mode options
+      // https://cloud.google.com/vertex-ai/generative-ai/docs/image/edit-insert-objects
+      mode: z
+        .enum([
+          'EDIT_MODE_INPAINT_INSERTION',
+          'EDIT_MODE_INPAINT_REMOVAL',
+          'EDIT_MODE_OUTPAINT',
+          'EDIT_MODE_CONTROLLED_EDITING',
+          'EDIT_MODE_PRODUCT_IMAGE',
+          'EDIT_MODE_BGSWAP',
+        ])
+        .nullish(),
+
+      /**
+       * The mask mode to use.
+       * - `MASK_MODE_DEFAULT` - Default value for mask mode.
+       * - `MASK_MODE_USER_PROVIDED` - User provided mask. No segmentation needed.
+       * - `MASK_MODE_DETECTION_BOX` - Mask from detected bounding boxes.
+       * - `MASK_MODE_CLOTHING_AREA` - Masks from segmenting the clothing area with open-vocab segmentation.
+       * - `MASK_MODE_PARSED_PERSON` - Masks from segmenting the person body and clothing using the person-parsing model.
+       */
+      maskMode: z
+        .enum([
+          'MASK_MODE_DEFAULT',
+          'MASK_MODE_USER_PROVIDED',
+          'MASK_MODE_DETECTION_BOX',
+          'MASK_MODE_CLOTHING_AREA',
+          'MASK_MODE_PARSED_PERSON',
+        ])
+        .nullish(),
+
+      /**
+       * Optional. A float value between 0 and 1, inclusive, that represents the
+       * percentage of the image width to grow the mask by. Using dilation helps
+       * compensate for imprecise masks. We recommend a value of 0.01.
+       */
+      maskDilation: z.number().nullish(),
+    })
+    .nullish(),
+});
+export type GoogleVertexImageModelOptions = z.infer<
+  typeof googleVertexImageModelOptionsSchema
+>;

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

@@ -22,6 +22,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { googleVertexFailedResponseHandler } from './google-vertex-error';
+import { googleVertexImageModelOptionsSchema } from './google-vertex-image-model-options';
 import type { GoogleVertexImageModelId } from './google-vertex-image-settings';
 
 interface GoogleVertexImageModelConfig {
@@ -103,14 +104,20 @@ export class GoogleVertexImageModel implements ImageModelV4 {
       });
     }
 
-    const vertexImageOptions = await parseProviderOptions({
-      provider: 'vertex',
-      providerOptions,
-      schema: googleVertexImageModelOptionsSchema,
-    });
+    const googleVertexImageOptions =
+      (await parseProviderOptions({
+        provider: 'googleVertex',
+        providerOptions,
+        schema: googleVertexImageModelOptionsSchema,
+      })) ??
+      (await parseProviderOptions({
+        provider: 'vertex',
+        providerOptions,
+        schema: googleVertexImageModelOptionsSchema,
+      }));
 
     // Extract edit-specific options from provider options
-    const { edit, ...otherOptions } = vertexImageOptions ?? {};
+    const { edit, ...otherOptions } = googleVertexImageOptions ?? {};
     const { mode: editMode, baseSteps, maskMode, maskDilation } = edit ?? {};
 
     // Build the request body based on whether we're editing or generating
@@ -188,7 +195,7 @@ export class GoogleVertexImageModel implements ImageModelV4 {
       body,
       failedResponseHandler: googleVertexFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
-        vertexImageResponseSchema,
+        googleVertexImageResponseSchema,
       ),
       abortSignal,
       fetch: this.config.fetch,
@@ -205,8 +212,8 @@ export class GoogleVertexImageModel implements ImageModelV4 {
         modelId: this.modelId,
         headers: responseHeaders,
       },
-      providerMetadata: {
-        vertex: {
+      providerMetadata: (() => {
+        const payload = {
           images:
             response.predictions?.map(prediction => {
               const {
@@ -216,8 +223,9 @@ export class GoogleVertexImageModel implements ImageModelV4 {
 
               return { ...(revisedPrompt != null && { revisedPrompt }) };
             }) ?? [],
-        },
-      },
+        };
+        return { googleVertex: payload, vertex: payload };
+      })(),
     };
   }
 
@@ -312,24 +320,27 @@ export class GoogleVertexImageModel implements ImageModelV4 {
       }),
     });
 
+    const userVertexOptions = (providerOptions?.googleVertex ??
+      providerOptions?.vertex) as
+      | Omit<GoogleLanguageModelOptions, 'responseModalities' | 'imageConfig'>
+      | undefined;
+    const innerVertexOptions: GoogleLanguageModelOptions = {
+      responseModalities: ['IMAGE'],
+      imageConfig: aspectRatio
+        ? {
+            aspectRatio: aspectRatio as NonNullable<
+              GoogleLanguageModelOptions['imageConfig']
+            >['aspectRatio'],
+          }
+        : undefined,
+      ...(userVertexOptions ?? {}),
+    };
     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,
+        googleVertex: innerVertexOptions,
+        vertex: innerVertexOptions,
       },
       headers,
       abortSignal,
@@ -348,13 +359,15 @@ export class GoogleVertexImageModel implements ImageModelV4 {
       }
     }
 
+    const geminiPayload = {
+      images: images.map(() => ({})),
+    };
     return {
       images,
       warnings,
       providerMetadata: {
-        vertex: {
-          images: images.map(() => ({})),
-        },
+        googleVertex: geminiPayload,
+        vertex: geminiPayload,
       },
       response: {
         timestamp: currentDate,
@@ -380,7 +393,7 @@ function isGeminiModel(modelId: string): boolean {
 
 // minimal version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const vertexImageResponseSchema = z.object({
+const googleVertexImageResponseSchema = z.object({
   predictions: z
     .array(
       z.object({
@@ -392,79 +405,6 @@ const vertexImageResponseSchema = z.object({
     .nullish(),
 });
 
-const googleVertexImageModelOptionsSchema = z.object({
-  negativePrompt: z.string().nullish(),
-  personGeneration: z
-    .enum(['dont_allow', 'allow_adult', 'allow_all'])
-    .nullish(),
-  safetySetting: z
-    .enum([
-      'block_low_and_above',
-      'block_medium_and_above',
-      'block_only_high',
-      'block_none',
-    ])
-    .nullish(),
-  addWatermark: z.boolean().nullish(),
-  storageUri: z.string().nullish(),
-  sampleImageSize: z.enum(['1K', '2K']).nullish(),
-  /**
-   * Configuration for image editing operations
-   */
-  edit: z
-    .object({
-      /**
-       * An integer that represents the number of sampling steps.
-       * A higher value offers better image quality, a lower value offers better latency.
-       * Try 35 steps to start. If the quality doesn't meet your requirements,
-       * increase the value towards an upper limit of 75.
-       */
-      baseSteps: z.number().nullish(),
-
-      // Edit mode options
-      // https://cloud.google.com/vertex-ai/generative-ai/docs/image/edit-insert-objects
-      mode: z
-        .enum([
-          'EDIT_MODE_INPAINT_INSERTION',
-          'EDIT_MODE_INPAINT_REMOVAL',
-          'EDIT_MODE_OUTPAINT',
-          'EDIT_MODE_CONTROLLED_EDITING',
-          'EDIT_MODE_PRODUCT_IMAGE',
-          'EDIT_MODE_BGSWAP',
-        ])
-        .nullish(),
-
-      /**
-       * The mask mode to use.
-       * - `MASK_MODE_DEFAULT` - Default value for mask mode.
-       * - `MASK_MODE_USER_PROVIDED` - User provided mask. No segmentation needed.
-       * - `MASK_MODE_DETECTION_BOX` - Mask from detected bounding boxes.
-       * - `MASK_MODE_CLOTHING_AREA` - Masks from segmenting the clothing area with open-vocab segmentation.
-       * - `MASK_MODE_PARSED_PERSON` - Masks from segmenting the person body and clothing using the person-parsing model.
-       */
-      maskMode: z
-        .enum([
-          'MASK_MODE_DEFAULT',
-          'MASK_MODE_USER_PROVIDED',
-          'MASK_MODE_DETECTION_BOX',
-          'MASK_MODE_CLOTHING_AREA',
-          'MASK_MODE_PARSED_PERSON',
-        ])
-        .nullish(),
-
-      /**
-       * Optional. A float value between 0 and 1, inclusive, that represents the
-       * percentage of the image width to grow the mask by. Using dilation helps
-       * compensate for imprecise masks. We recommend a value of 0.01.
-       */
-      maskDilation: z.number().nullish(),
-    })
-    .nullish(),
-});
-export type GoogleVertexImageModelOptions = z.infer<
-  typeof googleVertexImageModelOptionsSchema
->;
-
 /**
  * Helper to convert ImageModelV4File data to base64 string
  */

package/src/google-vertex-provider-base.ts

@@ -0,0 +1,245 @@
+import { GoogleLanguageModel } from '@ai-sdk/google/internal';
+import type {
+  Experimental_VideoModelV4,
+  ImageModelV4,
+  LanguageModelV4,
+  ProviderV4,
+} from '@ai-sdk/provider';
+import {
+  generateId,
+  loadOptionalSetting,
+  loadSetting,
+  normalizeHeaders,
+  resolve,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+  type FetchFunction,
+  type Resolvable,
+} from '@ai-sdk/provider-utils';
+import { VERSION } from './version';
+import type { GoogleVertexConfig } from './google-vertex-config';
+import { GoogleVertexEmbeddingModel } from './google-vertex-embedding-model';
+import type { GoogleVertexEmbeddingModelId } from './google-vertex-embedding-model-options';
+import { GoogleVertexImageModel } from './google-vertex-image-model';
+import type { GoogleVertexImageModelId } from './google-vertex-image-settings';
+import type { GoogleVertexModelId } from './google-vertex-options';
+import { googleVertexTools } from './google-vertex-tools';
+import { GoogleVertexVideoModel } from './google-vertex-video-model';
+import type { GoogleVertexVideoModelId } from './google-vertex-video-settings';
+
+const EXPRESS_MODE_BASE_URL =
+  'https://aiplatform.googleapis.com/v1/publishers/google';
+
+// set `x-goog-api-key` header to API key for express mode
+function createExpressModeFetch(
+  apiKey: string,
+  customFetch?: FetchFunction,
+): FetchFunction {
+  return async (url, init) => {
+    const modifiedInit: RequestInit = {
+      ...init,
+      headers: {
+        ...(init?.headers ? normalizeHeaders(init.headers) : {}),
+        'x-goog-api-key': apiKey,
+      },
+    };
+    return (customFetch ?? fetch)(url.toString(), modifiedInit);
+  };
+}
+
+export interface GoogleVertexProvider extends ProviderV4 {
+  /**
+   * Creates a model for text generation.
+   */
+  (modelId: GoogleVertexModelId): LanguageModelV4;
+
+  languageModel: (modelId: GoogleVertexModelId) => LanguageModelV4;
+
+  /**
+   * Creates a model for image generation.
+   */
+  image(modelId: GoogleVertexImageModelId): ImageModelV4;
+
+  /**
+   * Creates a model for image generation.
+   */
+  imageModel(modelId: GoogleVertexImageModelId): ImageModelV4;
+
+  tools: typeof googleVertexTools;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(
+    modelId: GoogleVertexEmbeddingModelId,
+  ): GoogleVertexEmbeddingModel;
+
+  /**
+   * Creates a model for video generation.
+   */
+  video(modelId: GoogleVertexVideoModelId): Experimental_VideoModelV4;
+
+  /**
+   * Creates a model for video generation.
+   */
+  videoModel(modelId: GoogleVertexVideoModelId): Experimental_VideoModelV4;
+}
+
+export interface GoogleVertexProviderSettings {
+  /**
+   * Optional. The API key for the Google Cloud project. If provided, the
+   * provider will use express mode with API key authentication. Defaults to
+   * the value of the `GOOGLE_VERTEX_API_KEY` environment variable.
+   */
+  apiKey?: string;
+
+  /**
+   * Your Google Vertex location. Defaults to the environment variable `GOOGLE_VERTEX_LOCATION`.
+   */
+  location?: string;
+
+  /**
+   * Your Google Vertex project. Defaults to the environment variable `GOOGLE_VERTEX_PROJECT`.
+   */
+  project?: string;
+
+  /**
+   * Headers to use for requests. Can be:
+   * - A headers object
+   * - A Promise that resolves to a headers object
+   * - A function that returns a headers object
+   * - A function that returns a Promise of a headers object
+   */
+  headers?: Resolvable<Record<string, string | undefined>>;
+
+  /**
+   * Custom fetch implementation. You can use it as a middleware to intercept requests,
+   * or to provide a custom fetch implementation for e.g. testing.
+   */
+  fetch?: FetchFunction;
+
+  // for testing
+  generateId?: () => string;
+
+  /**
+   * Base URL for the Google Vertex API calls.
+   */
+  baseURL?: string;
+}
+
+/**
+ * Create a Google Vertex AI provider instance.
+ */
+export function createGoogleVertex(
+  options: GoogleVertexProviderSettings = {},
+): GoogleVertexProvider {
+  const apiKey = loadOptionalSetting({
+    settingValue: options.apiKey,
+    environmentVariableName: 'GOOGLE_VERTEX_API_KEY',
+  });
+
+  const loadGoogleVertexProject = () =>
+    loadSetting({
+      settingValue: options.project,
+      settingName: 'project',
+      environmentVariableName: 'GOOGLE_VERTEX_PROJECT',
+      description: 'Google Vertex project',
+    });
+
+  const loadGoogleVertexLocation = () =>
+    loadSetting({
+      settingValue: options.location,
+      settingName: 'location',
+      environmentVariableName: 'GOOGLE_VERTEX_LOCATION',
+      description: 'Google Vertex location',
+    });
+
+  const loadBaseURL = () => {
+    if (apiKey) {
+      return withoutTrailingSlash(options.baseURL) ?? EXPRESS_MODE_BASE_URL;
+    }
+
+    const region = loadGoogleVertexLocation();
+    const project = loadGoogleVertexProject();
+
+    // For global region, use aiplatform.googleapis.com directly
+    // For other regions, use region-aiplatform.googleapis.com
+    const baseHost = `${region === 'global' ? '' : region + '-'}aiplatform.googleapis.com`;
+
+    return (
+      withoutTrailingSlash(options.baseURL) ??
+      `https://${baseHost}/v1beta1/projects/${project}/locations/${region}/publishers/google`
+    );
+  };
+
+  const createConfig = (name: string): GoogleVertexConfig => {
+    const getHeaders = async () => {
+      const originalHeaders = await resolve(options.headers ?? {});
+      return withUserAgentSuffix(
+        originalHeaders,
+        `ai-sdk/google-vertex/${VERSION}`,
+      );
+    };
+
+    return {
+      provider: `google.vertex.${name}`,
+      headers: getHeaders,
+      fetch: apiKey
+        ? createExpressModeFetch(apiKey, options.fetch)
+        : options.fetch,
+      baseURL: loadBaseURL(),
+    };
+  };
+
+  const createChatModel = (modelId: GoogleVertexModelId) => {
+    return new GoogleLanguageModel(modelId, {
+      ...createConfig('chat'),
+      generateId: options.generateId ?? generateId,
+      supportedUrls: () => ({
+        '*': [
+          // HTTP URLs:
+          /^https?:\/\/.*$/,
+          // Google Cloud Storage URLs:
+          /^gs:\/\/.*$/,
+        ],
+      }),
+    });
+  };
+
+  const createEmbeddingModel = (modelId: GoogleVertexEmbeddingModelId) =>
+    new GoogleVertexEmbeddingModel(modelId, createConfig('embedding'));
+
+  const createImageModel = (modelId: GoogleVertexImageModelId) =>
+    new GoogleVertexImageModel(modelId, {
+      ...createConfig('image'),
+      generateId: options.generateId ?? generateId,
+    });
+
+  const createVideoModel = (modelId: GoogleVertexVideoModelId) =>
+    new GoogleVertexVideoModel(modelId, {
+      ...createConfig('video'),
+      generateId: options.generateId ?? generateId,
+    });
+
+  const provider = function (modelId: GoogleVertexModelId) {
+    if (new.target) {
+      throw new Error(
+        'The Google Vertex AI model function cannot be called with the new keyword.',
+      );
+    }
+
+    return createChatModel(modelId);
+  };
+
+  provider.specificationVersion = 'v4' as const;
+  provider.languageModel = createChatModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  provider.video = createVideoModel;
+  provider.videoModel = createVideoModel;
+  provider.tools = googleVertexTools;
+
+  return provider;
+}