@ai-sdk/google-vertex 4.0.219 → 4.0.221

package/src/gemini-transcription/google-vertex-gemini-transcription-model-options.ts

@@ -1,3 +1,8 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 export type GoogleVertexGeminiTranscriptionModelId =
@@ -11,41 +16,45 @@ export type GoogleVertexGeminiTranscriptionModelId =
  * The live variant (`gemini-3.5-transcribe-live`) requires streaming
  * transcription, which is only available in AI SDK v7.
  */
-export const googleVertexGeminiTranscriptionModelOptions = z.object({
-  /**
-   * BCP-47 language codes providing hints about the languages present in the
-   * audio. If omitted or empty, defaults to automatic language detection.
-   */
-  languageCodes: z.array(z.string()).optional(),
+export const googleVertexGeminiTranscriptionModelOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * BCP-47 language codes providing hints about the languages present in the
+       * audio. If omitted or empty, defaults to automatic language detection.
+       */
+      languageCodes: z.array(z.string()).optional(),
 
-  /**
-   * Custom vocabulary phrases, which bias the speech recognition model
-   * toward recognizing specific terms.
-   */
-  customVocabulary: z.array(z.string()).optional(),
+      /**
+       * Custom vocabulary phrases, which bias the speech recognition model
+       * toward recognizing specific terms.
+       */
+      customVocabulary: z.array(z.string()).optional(),
 
-  /**
-   * Enables word-level timestamp generation.
-   */
-  wordTimestamp: z.boolean().optional(),
+      /**
+       * Enables word-level timestamp generation.
+       */
+      wordTimestamp: z.boolean().optional(),
 
-  /**
-   * Enables speaker diarization.
-   */
-  diarization: z.boolean().optional(),
+      /**
+       * Enables speaker diarization.
+       */
+      diarization: z.boolean().optional(),
 
-  /**
-   * Transcription output formatting mode.
-   *
-   * - `VERBATIM` (default): exact literal transcript preserving filler
-   *   words, repetitions, and false starts.
-   * - `SMART`: cleans up and structures the transcript in real time —
-   *   disfluency removal, inline self-corrections, structured formatting
-   *   (lists, numbers, dates, paragraph breaks), and grammar/casing polish.
-   */
-  mode: z.enum(['SMART', 'VERBATIM']).optional(),
-});
+      /**
+       * Transcription output formatting mode.
+       *
+       * - `VERBATIM` (default): exact literal transcript preserving filler
+       *   words, repetitions, and false starts.
+       * - `SMART`: cleans up and structures the transcript in real time —
+       *   disfluency removal, inline self-corrections, structured formatting
+       *   (lists, numbers, dates, paragraph breaks), and grammar/casing polish.
+       */
+      mode: z.enum(['SMART', 'VERBATIM']).optional(),
+    }),
+  ),
+);
 
-export type GoogleVertexTranscriptionModelGeminiOptions = z.infer<
+export type GoogleVertexTranscriptionModelGeminiOptions = InferSchema<
   typeof googleVertexGeminiTranscriptionModelOptions
 >;

package/src/gemini-transcription/google-vertex-gemini-transcription-model.ts

@@ -5,6 +5,8 @@ import {
   type TranscriptionModelV3,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   convertToBase64,
   createJsonResponseHandler,
@@ -215,39 +217,44 @@ function parseOffsetSeconds(
   return Number.isFinite(parsed) ? parsed : undefined;
 }
 
-const googleVertexGeminiTranscriptionWordSchema = z.object({
-  word: z.string().nullish(),
-  startOffset: z.string().nullish(),
-  endOffset: z.string().nullish(),
-});
-
-const googleVertexGeminiTranscriptionResponseSchema = z.object({
-  candidates: z
-    .array(
-      z.object({
-        content: z
-          .object({
-            parts: z
-              .array(
-                z.object({
-                  text: z.string().nullish(),
-                  audioTranscription: z
-                    .object({
+const googleVertexGeminiTranscriptionWordSchema = () =>
+  z.object({
+    word: z.string().nullish(),
+    startOffset: z.string().nullish(),
+    endOffset: z.string().nullish(),
+  });
+
+const googleVertexGeminiTranscriptionResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      candidates: z
+        .array(
+          z.object({
+            content: z
+              .object({
+                parts: z
+                  .array(
+                    z.object({
                       text: z.string().nullish(),
-                      languageCode: z.string().nullish(),
-                      speakerLabel: z.string().nullish(),
-                      words: z
-                        .array(googleVertexGeminiTranscriptionWordSchema)
+                      audioTranscription: z
+                        .object({
+                          text: z.string().nullish(),
+                          languageCode: z.string().nullish(),
+                          speakerLabel: z.string().nullish(),
+                          words: z
+                            .array(googleVertexGeminiTranscriptionWordSchema())
+                            .nullish(),
+                        })
                         .nullish(),
-                    })
-                    .nullish(),
-                }),
-              )
+                    }),
+                  )
+                  .nullish(),
+              })
               .nullish(),
-          })
-          .nullish(),
-      }),
-    )
-    .nullish(),
-  usageMetadata: z.record(z.string(), z.unknown()).nullish(),
-});
+          }),
+        )
+        .nullish(),
+      usageMetadata: z.record(z.string(), z.unknown()).nullish(),
+    }),
+  ),
+);

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

@@ -3,6 +3,8 @@ import {
   type EmbeddingModelV3,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createJsonResponseHandler,
   postJsonToApi,
@@ -162,29 +164,37 @@ export class GoogleVertexEmbeddingModel implements EmbeddingModelV3 {
 
 // 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 googleVertexTextEmbeddingResponseSchema = z.object({
-  predictions: z.array(
+const googleVertexTextEmbeddingResponseSchema = lazySchema(() =>
+  zodSchema(
     z.object({
-      embeddings: z.object({
-        values: z.array(z.number()),
-        statistics: z.object({
-          token_count: z.number(),
+      predictions: z.array(
+        z.object({
+          embeddings: z.object({
+            values: z.array(z.number()),
+            statistics: z.object({
+              token_count: z.number(),
+            }),
+          }),
         }),
+      ),
+    }),
+  ),
+);
+
+const googleVertexEmbedContentResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      embedding: z.object({
+        values: z.array(z.number()),
       }),
+      usageMetadata: z
+        .object({
+          promptTokenCount: z.number().nullish(),
+        })
+        .nullish(),
     }),
   ),
-});
-
-const googleVertexEmbedContentResponseSchema = z.object({
-  embedding: z.object({
-    values: z.array(z.number()),
-  }),
-  usageMetadata: z
-    .object({
-      promptTokenCount: z.number().nullish(),
-    })
-    .nullish(),
-});
+);
 
 function usesEmbedContentEndpoint(modelId: GoogleVertexEmbeddingModelId) {
   return (

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

@@ -1,3 +1,8 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 // https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/text-embeddings-api
@@ -14,52 +19,56 @@ export type GoogleVertexEmbeddingModelId =
   | 'gemini-embedding-2-preview'
   | (string & {});
 
-export const googleVertexEmbeddingModelOptions = z.object({
-  /**
-   * Optional. Optional reduced dimension for the output embedding.
-   * If set, excessive values in the output embedding are truncated from the end.
-   */
-  outputDimensionality: z.number().optional(),
+export const googleVertexEmbeddingModelOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * Optional. Optional reduced dimension for the output embedding.
+       * If set, excessive values in the output embedding are truncated from the end.
+       */
+      outputDimensionality: z.number().optional(),
 
-  /**
-   * Optional. Specifies the task type for generating embeddings.
-   * Supported task types:
-   * - SEMANTIC_SIMILARITY: Optimized for text similarity.
-   * - CLASSIFICATION: Optimized for text classification.
-   * - CLUSTERING: Optimized for clustering texts based on similarity.
-   * - RETRIEVAL_DOCUMENT: Optimized for document retrieval.
-   * - RETRIEVAL_QUERY: Optimized for query-based retrieval.
-   * - QUESTION_ANSWERING: Optimized for answering questions.
-   * - FACT_VERIFICATION: Optimized for verifying factual information.
-   * - CODE_RETRIEVAL_QUERY: Optimized for retrieving code blocks based on natural language queries.
-   */
-  taskType: z
-    .enum([
-      'SEMANTIC_SIMILARITY',
-      'CLASSIFICATION',
-      'CLUSTERING',
-      'RETRIEVAL_DOCUMENT',
-      'RETRIEVAL_QUERY',
-      'QUESTION_ANSWERING',
-      'FACT_VERIFICATION',
-      'CODE_RETRIEVAL_QUERY',
-    ])
-    .optional(),
+      /**
+       * Optional. Specifies the task type for generating embeddings.
+       * Supported task types:
+       * - SEMANTIC_SIMILARITY: Optimized for text similarity.
+       * - CLASSIFICATION: Optimized for text classification.
+       * - CLUSTERING: Optimized for clustering texts based on similarity.
+       * - RETRIEVAL_DOCUMENT: Optimized for document retrieval.
+       * - RETRIEVAL_QUERY: Optimized for query-based retrieval.
+       * - QUESTION_ANSWERING: Optimized for answering questions.
+       * - FACT_VERIFICATION: Optimized for verifying factual information.
+       * - CODE_RETRIEVAL_QUERY: Optimized for retrieving code blocks based on natural language queries.
+       */
+      taskType: z
+        .enum([
+          'SEMANTIC_SIMILARITY',
+          'CLASSIFICATION',
+          'CLUSTERING',
+          'RETRIEVAL_DOCUMENT',
+          'RETRIEVAL_QUERY',
+          'QUESTION_ANSWERING',
+          'FACT_VERIFICATION',
+          'CODE_RETRIEVAL_QUERY',
+        ])
+        .optional(),
 
-  /**
-   * Optional. The title of the document being embedded.
-   * Only valid when task_type is set to 'RETRIEVAL_DOCUMENT'.
-   * Helps the model produce better embeddings by providing additional context.
-   */
-  title: z.string().optional(),
+      /**
+       * Optional. The title of the document being embedded.
+       * Only valid when task_type is set to 'RETRIEVAL_DOCUMENT'.
+       * Helps the model produce better embeddings by providing additional context.
+       */
+      title: z.string().optional(),
 
-  /**
-   * Optional. When set to true, input text will be truncated. When set to false,
-   * an error is returned if the input text is longer than the maximum length supported by the model. Defaults to true.
-   */
-  autoTruncate: z.boolean().optional(),
-});
+      /**
+       * Optional. When set to true, input text will be truncated. When set to false,
+       * an error is returned if the input text is longer than the maximum length supported by the model. Defaults to true.
+       */
+      autoTruncate: z.boolean().optional(),
+    }),
+  ),
+);
 
-export type GoogleVertexEmbeddingModelOptions = z.infer<
+export type GoogleVertexEmbeddingModelOptions = InferSchema<
   typeof googleVertexEmbeddingModelOptions
 >;

package/src/google-vertex-error.ts

@@ -1,15 +1,26 @@
-import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+  createJsonErrorResponseHandler,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
-const googleVertexErrorDataSchema = z.object({
-  error: z.object({
-    code: z.number().nullable(),
-    message: z.string(),
-    status: z.string(),
-  }),
-});
+const googleVertexErrorDataSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      error: z.object({
+        code: z.number().nullable(),
+        message: z.string(),
+        status: z.string(),
+      }),
+    }),
+  ),
+);
 
-export type GoogleVertexErrorData = z.infer<typeof googleVertexErrorDataSchema>;
+export type GoogleVertexErrorData = InferSchema<
+  typeof googleVertexErrorDataSchema
+>;
 
 export const googleVertexFailedResponseHandler = createJsonErrorResponseHandler(
   {

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

@@ -7,6 +7,9 @@ import type {
   SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
   combineHeaders,
   convertToBase64,
   convertUint8ArrayToBase64,
@@ -363,91 +366,99 @@ 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({
-  predictions: z
-    .array(
-      z.union([
-        z.object({
-          bytesBase64Encoded: z.string(),
-          mimeType: z.string(),
-          prompt: z.string().nullish(),
-        }),
-        z.object({ raiFilteredReason: z.string() }),
-      ]),
-    )
-    .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',
-        ])
+const vertexImageResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      predictions: z
+        .array(
+          z.union([
+            z.object({
+              bytesBase64Encoded: z.string(),
+              mimeType: z.string(),
+              prompt: z.string().nullish(),
+            }),
+            z.object({ raiFilteredReason: z.string() }),
+          ]),
+        )
         .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
+    }),
+  ),
+);
+
+const googleVertexImageModelOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      negativePrompt: z.string().nullish(),
+      personGeneration: z
+        .enum(['dont_allow', 'allow_adult', 'allow_all'])
+        .nullish(),
+      safetySetting: z
         .enum([
-          'MASK_MODE_DEFAULT',
-          'MASK_MODE_USER_PROVIDED',
-          'MASK_MODE_DETECTION_BOX',
-          'MASK_MODE_CLOTHING_AREA',
-          'MASK_MODE_PARSED_PERSON',
+          '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(),
       /**
-       * 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.
+       * Configuration for image editing operations
        */
-      maskDilation: z.number().nullish(),
-    })
-    .nullish(),
-});
-export type GoogleVertexImageModelOptions = z.infer<
+      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 = InferSchema<
   typeof googleVertexImageModelOptionsSchema
 >;
 

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

@@ -1,3 +1,8 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 // Google Cloud Speech-to-Text transcription models (Speech-to-Text v2).
@@ -8,39 +13,43 @@ export type GoogleVertexTranscriptionModelId =
   | 'telephony'
   | (string & {});
 
-export const googleVertexTranscriptionProviderOptionsSchema = z.object({
-  /**
-   * BCP-47 language codes to recognize (e.g. `['en-US']`), or `['auto']` to let
-   * Chirp auto-detect the spoken language. Defaults to `['auto']`. For
-   * `telephony`, pass a supported explicit language code.
-   */
-  languageCodes: z.array(z.string()).optional(),
+export const googleVertexTranscriptionProviderOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * BCP-47 language codes to recognize (e.g. `['en-US']`), or `['auto']` to let
+       * Chirp auto-detect the spoken language. Defaults to `['auto']`. For
+       * `telephony`, pass a supported explicit language code.
+       */
+      languageCodes: z.array(z.string()).optional(),
 
-  /**
-   * Whether to add punctuation to the transcript. Defaults to `true`.
-   */
-  enableAutomaticPunctuation: z.boolean().optional(),
+      /**
+       * Whether to add punctuation to the transcript. Defaults to `true`.
+       */
+      enableAutomaticPunctuation: z.boolean().optional(),
 
-  /**
-   * Whether to include word-level timestamps. Defaults to `true` so the
-   * transcription result can include segments.
-   *
-   * Enabling word-level timestamps can reduce transcription quality and speed
-   * for Chirp models.
-   */
-  enableWordTimeOffsets: z.boolean().optional(),
+      /**
+       * Whether to include word-level timestamps. Defaults to `true` so the
+       * transcription result can include segments.
+       *
+       * Enabling word-level timestamps can reduce transcription quality and speed
+       * for Chirp models.
+       */
+      enableWordTimeOffsets: z.boolean().optional(),
 
-  /**
-   * The Cloud Speech-to-Text region for the request (e.g. `'us'`, `'eu'`,
-   * `'us-central1'`). Defaults to the provider `location`.
-   *
-   * Note: Speech-to-Text regions differ from Vertex AI regions. Chirp is only
-   * available in specific Speech-to-Text regions and is not available in the
-   * `global` location.
-   */
-  region: z.string().optional(),
-});
+      /**
+       * The Cloud Speech-to-Text region for the request (e.g. `'us'`, `'eu'`,
+       * `'us-central1'`). Defaults to the provider `location`.
+       *
+       * Note: Speech-to-Text regions differ from Vertex AI regions. Chirp is only
+       * available in specific Speech-to-Text regions and is not available in the
+       * `global` location.
+       */
+      region: z.string().optional(),
+    }),
+  ),
+);
 
-export type GoogleVertexTranscriptionModelOptions = z.infer<
+export type GoogleVertexTranscriptionModelOptions = InferSchema<
   typeof googleVertexTranscriptionProviderOptionsSchema
 >;