@ai-sdk/google-vertex 4.0.219 → 4.0.221

package/dist/edge/index.mjs

@@ -17,13 +17,15 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "4.0.219" : "0.0.0-test";
+var VERSION = true ? "4.0.221" : "0.0.0-test";
 
 // src/google-vertex-embedding-model.ts
 import {
   TooManyEmbeddingValuesForCallError
 } from "@ai-sdk/provider";
 import {
+  lazySchema as lazySchema3,
+  zodSchema as zodSchema3,
   combineHeaders,
   createJsonResponseHandler,
   postJsonToApi,
@@ -33,15 +35,23 @@ import {
 import { z as z3 } from "zod/v4";
 
 // src/google-vertex-error.ts
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import {
+  lazySchema,
+  zodSchema,
+  createJsonErrorResponseHandler
+} from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
-var googleVertexErrorDataSchema = z.object({
-  error: z.object({
-    code: z.number().nullable(),
-    message: z.string(),
-    status: z.string()
-  })
-});
+var googleVertexErrorDataSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      error: z.object({
+        code: z.number().nullable(),
+        message: z.string(),
+        status: z.string()
+      })
+    })
+  )
+);
 var googleVertexFailedResponseHandler = createJsonErrorResponseHandler(
   {
     errorSchema: googleVertexErrorDataSchema,
@@ -50,47 +60,55 @@ var googleVertexFailedResponseHandler = createJsonErrorResponseHandler(
 );
 
 // src/google-vertex-embedding-options.ts
+import {
+  lazySchema as lazySchema2,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
 import { z as z2 } from "zod/v4";
-var googleVertexEmbeddingModelOptions = z2.object({
-  /**
-   * Optional. Optional reduced dimension for the output embedding.
-   * If set, excessive values in the output embedding are truncated from the end.
-   */
-  outputDimensionality: z2.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: z2.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: z2.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: z2.boolean().optional()
-});
+var googleVertexEmbeddingModelOptions = lazySchema2(
+  () => zodSchema2(
+    z2.object({
+      /**
+       * Optional. Optional reduced dimension for the output embedding.
+       * If set, excessive values in the output embedding are truncated from the end.
+       */
+      outputDimensionality: z2.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: z2.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: z2.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: z2.boolean().optional()
+    })
+  )
+);
 
 // src/google-vertex-embedding-model.ts
 var GoogleVertexEmbeddingModel = class {
@@ -212,26 +230,34 @@ var GoogleVertexEmbeddingModel = class {
     };
   }
 };
-var googleVertexTextEmbeddingResponseSchema = z3.object({
-  predictions: z3.array(
+var googleVertexTextEmbeddingResponseSchema = lazySchema3(
+  () => zodSchema3(
     z3.object({
-      embeddings: z3.object({
-        values: z3.array(z3.number()),
-        statistics: z3.object({
-          token_count: z3.number()
+      predictions: z3.array(
+        z3.object({
+          embeddings: z3.object({
+            values: z3.array(z3.number()),
+            statistics: z3.object({
+              token_count: z3.number()
+            })
+          })
         })
-      })
+      )
     })
   )
-});
-var googleVertexEmbedContentResponseSchema = z3.object({
-  embedding: z3.object({
-    values: z3.array(z3.number())
-  }),
-  usageMetadata: z3.object({
-    promptTokenCount: z3.number().nullish()
-  }).nullish()
-});
+);
+var googleVertexEmbedContentResponseSchema = lazySchema3(
+  () => zodSchema3(
+    z3.object({
+      embedding: z3.object({
+        values: z3.array(z3.number())
+      }),
+      usageMetadata: z3.object({
+        promptTokenCount: z3.number().nullish()
+      }).nullish()
+    })
+  )
+);
 function usesEmbedContentEndpoint(modelId) {
   return modelId === "gemini-embedding-2" || modelId === "gemini-embedding-2-preview";
 }
@@ -239,6 +265,8 @@ function usesEmbedContentEndpoint(modelId) {
 // src/google-vertex-image-model.ts
 import { GoogleGenerativeAILanguageModel } from "@ai-sdk/google/internal";
 import {
+  lazySchema as lazySchema4,
+  zodSchema as zodSchema4,
   combineHeaders as combineHeaders2,
   convertToBase64,
   convertUint8ArrayToBase64,
@@ -505,74 +533,82 @@ var GoogleVertexImageModel = class {
 function isGeminiModel(modelId) {
   return modelId.startsWith("gemini-");
 }
-var vertexImageResponseSchema = z4.object({
-  predictions: z4.array(
-    z4.union([
-      z4.object({
-        bytesBase64Encoded: z4.string(),
-        mimeType: z4.string(),
-        prompt: z4.string().nullish()
-      }),
-      z4.object({ raiFilteredReason: z4.string() })
-    ])
-  ).nullish()
-});
-var googleVertexImageModelOptionsSchema = z4.object({
-  negativePrompt: z4.string().nullish(),
-  personGeneration: z4.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-  safetySetting: z4.enum([
-    "block_low_and_above",
-    "block_medium_and_above",
-    "block_only_high",
-    "block_none"
-  ]).nullish(),
-  addWatermark: z4.boolean().nullish(),
-  storageUri: z4.string().nullish(),
-  sampleImageSize: z4.enum(["1K", "2K"]).nullish(),
-  /**
-   * Configuration for image editing operations
-   */
-  edit: z4.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: z4.number().nullish(),
-    // Edit mode options
-    // https://cloud.google.com/vertex-ai/generative-ai/docs/image/edit-insert-objects
-    mode: z4.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: z4.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: z4.number().nullish()
-  }).nullish()
-});
+var vertexImageResponseSchema = lazySchema4(
+  () => zodSchema4(
+    z4.object({
+      predictions: z4.array(
+        z4.union([
+          z4.object({
+            bytesBase64Encoded: z4.string(),
+            mimeType: z4.string(),
+            prompt: z4.string().nullish()
+          }),
+          z4.object({ raiFilteredReason: z4.string() })
+        ])
+      ).nullish()
+    })
+  )
+);
+var googleVertexImageModelOptionsSchema = lazySchema4(
+  () => zodSchema4(
+    z4.object({
+      negativePrompt: z4.string().nullish(),
+      personGeneration: z4.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+      safetySetting: z4.enum([
+        "block_low_and_above",
+        "block_medium_and_above",
+        "block_only_high",
+        "block_none"
+      ]).nullish(),
+      addWatermark: z4.boolean().nullish(),
+      storageUri: z4.string().nullish(),
+      sampleImageSize: z4.enum(["1K", "2K"]).nullish(),
+      /**
+       * Configuration for image editing operations
+       */
+      edit: z4.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: z4.number().nullish(),
+        // Edit mode options
+        // https://cloud.google.com/vertex-ai/generative-ai/docs/image/edit-insert-objects
+        mode: z4.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: z4.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: z4.number().nullish()
+      }).nullish()
+    })
+  )
+);
 function getBase64Data(file) {
   if (file.type === "url") {
     throw new Error(
@@ -599,6 +635,8 @@ var googleVertexTools = {
 
 // src/google-vertex-transcription-model.ts
 import {
+  lazySchema as lazySchema6,
+  zodSchema as zodSchema6,
   combineHeaders as combineHeaders3,
   convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
   createJsonResponseHandler as createJsonResponseHandler3,
@@ -609,36 +647,44 @@ import {
 import { z as z6 } from "zod/v4";
 
 // src/google-vertex-transcription-model-options.ts
+import {
+  lazySchema as lazySchema5,
+  zodSchema as zodSchema5
+} from "@ai-sdk/provider-utils";
 import { z as z5 } from "zod/v4";
-var googleVertexTranscriptionProviderOptionsSchema = z5.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: z5.array(z5.string()).optional(),
-  /**
-   * Whether to add punctuation to the transcript. Defaults to `true`.
-   */
-  enableAutomaticPunctuation: z5.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: z5.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: z5.string().optional()
-});
+var googleVertexTranscriptionProviderOptionsSchema = lazySchema5(
+  () => zodSchema5(
+    z5.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: z5.array(z5.string()).optional(),
+      /**
+       * Whether to add punctuation to the transcript. Defaults to `true`.
+       */
+      enableAutomaticPunctuation: z5.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: z5.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: z5.string().optional()
+    })
+  )
+);
 
 // src/google-vertex-transcription-model.ts
 function parseDurationSeconds(value) {
@@ -753,34 +799,40 @@ var GoogleVertexTranscriptionModel = class {
     };
   }
 };
-var googleVertexTranscriptionResponseSchema = z6.object({
-  results: z6.array(
+var googleVertexTranscriptionResponseSchema = lazySchema6(
+  () => zodSchema6(
     z6.object({
-      alternatives: z6.array(
+      results: z6.array(
         z6.object({
-          transcript: z6.string().nullish(),
-          words: z6.array(
+          alternatives: z6.array(
             z6.object({
-              word: z6.string().nullish(),
-              startOffset: z6.string().nullish(),
-              endOffset: z6.string().nullish()
+              transcript: z6.string().nullish(),
+              words: z6.array(
+                z6.object({
+                  word: z6.string().nullish(),
+                  startOffset: z6.string().nullish(),
+                  endOffset: z6.string().nullish()
+                })
+              ).nullish()
             })
-          ).nullish()
+          ).nullish(),
+          languageCode: z6.string().nullish()
         })
       ).nullish(),
-      languageCode: z6.string().nullish()
+      metadata: z6.object({
+        totalBilledDuration: z6.string().nullish()
+      }).nullish()
     })
-  ).nullish(),
-  metadata: z6.object({
-    totalBilledDuration: z6.string().nullish()
-  }).nullish()
-});
+  )
+);
 
 // src/gemini-transcription/google-vertex-gemini-transcription-model.ts
 import {
   InvalidArgumentError
 } from "@ai-sdk/provider";
 import {
+  lazySchema as lazySchema8,
+  zodSchema as zodSchema8,
   combineHeaders as combineHeaders4,
   convertToBase64 as convertToBase642,
   createJsonResponseHandler as createJsonResponseHandler4,
@@ -791,37 +843,45 @@ import {
 import { z as z8 } from "zod/v4";
 
 // src/gemini-transcription/google-vertex-gemini-transcription-model-options.ts
+import {
+  lazySchema as lazySchema7,
+  zodSchema as zodSchema7
+} from "@ai-sdk/provider-utils";
 import { z as z7 } from "zod/v4";
-var googleVertexGeminiTranscriptionModelOptions = z7.object({
-  /**
-   * BCP-47 language codes providing hints about the languages present in the
-   * audio. If omitted or empty, defaults to automatic language detection.
-   */
-  languageCodes: z7.array(z7.string()).optional(),
-  /**
-   * Custom vocabulary phrases, which bias the speech recognition model
-   * toward recognizing specific terms.
-   */
-  customVocabulary: z7.array(z7.string()).optional(),
-  /**
-   * Enables word-level timestamp generation.
-   */
-  wordTimestamp: z7.boolean().optional(),
-  /**
-   * Enables speaker diarization.
-   */
-  diarization: z7.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: z7.enum(["SMART", "VERBATIM"]).optional()
-});
+var googleVertexGeminiTranscriptionModelOptions = lazySchema7(
+  () => zodSchema7(
+    z7.object({
+      /**
+       * BCP-47 language codes providing hints about the languages present in the
+       * audio. If omitted or empty, defaults to automatic language detection.
+       */
+      languageCodes: z7.array(z7.string()).optional(),
+      /**
+       * Custom vocabulary phrases, which bias the speech recognition model
+       * toward recognizing specific terms.
+       */
+      customVocabulary: z7.array(z7.string()).optional(),
+      /**
+       * Enables word-level timestamp generation.
+       */
+      wordTimestamp: z7.boolean().optional(),
+      /**
+       * Enables speaker diarization.
+       */
+      diarization: z7.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: z7.enum(["SMART", "VERBATIM"]).optional()
+    })
+  )
+);
 
 // src/gemini-transcription/google-vertex-gemini-transcription-model.ts
 function isLiveTranscriptionModelId(modelId) {
@@ -963,31 +1023,35 @@ function parseOffsetSeconds(offset) {
   const parsed = Number.parseFloat(offset);
   return Number.isFinite(parsed) ? parsed : void 0;
 }
-var googleVertexGeminiTranscriptionWordSchema = z8.object({
+var googleVertexGeminiTranscriptionWordSchema = () => z8.object({
   word: z8.string().nullish(),
   startOffset: z8.string().nullish(),
   endOffset: z8.string().nullish()
 });
-var googleVertexGeminiTranscriptionResponseSchema = z8.object({
-  candidates: z8.array(
+var googleVertexGeminiTranscriptionResponseSchema = lazySchema8(
+  () => zodSchema8(
     z8.object({
-      content: z8.object({
-        parts: z8.array(
-          z8.object({
-            text: z8.string().nullish(),
-            audioTranscription: z8.object({
-              text: z8.string().nullish(),
-              languageCode: z8.string().nullish(),
-              speakerLabel: z8.string().nullish(),
-              words: z8.array(googleVertexGeminiTranscriptionWordSchema).nullish()
-            }).nullish()
-          })
-        ).nullish()
-      }).nullish()
+      candidates: z8.array(
+        z8.object({
+          content: z8.object({
+            parts: z8.array(
+              z8.object({
+                text: z8.string().nullish(),
+                audioTranscription: z8.object({
+                  text: z8.string().nullish(),
+                  languageCode: z8.string().nullish(),
+                  speakerLabel: z8.string().nullish(),
+                  words: z8.array(googleVertexGeminiTranscriptionWordSchema()).nullish()
+                }).nullish()
+              })
+            ).nullish()
+          }).nullish()
+        })
+      ).nullish(),
+      usageMetadata: z8.record(z8.string(), z8.unknown()).nullish()
     })
-  ).nullish(),
-  usageMetadata: z8.record(z8.string(), z8.unknown()).nullish()
-});
+  )
+);
 
 // src/google-vertex-video-model.ts
 import {
@@ -998,11 +1062,11 @@ import {
   convertUint8ArrayToBase64 as convertUint8ArrayToBase643,
   createJsonResponseHandler as createJsonResponseHandler5,
   delay,
-  lazySchema,
+  lazySchema as lazySchema9,
   parseProviderOptions as parseProviderOptions5,
   postJsonToApi as postJsonToApi5,
   resolve as resolve5,
-  zodSchema
+  zodSchema as zodSchema9
 } from "@ai-sdk/provider-utils";
 import { z as z9 } from "zod/v4";
 function getFirstFrameImage(options) {
@@ -1267,27 +1331,31 @@ var GoogleVertexVideoModel = class {
     };
   }
 };
-var vertexOperationSchema = z9.object({
-  name: z9.string().nullish(),
-  done: z9.boolean().nullish(),
-  error: z9.object({
-    code: z9.number().nullish(),
-    message: z9.string(),
-    status: z9.string().nullish()
-  }).nullish(),
-  response: z9.object({
-    videos: z9.array(
-      z9.object({
-        bytesBase64Encoded: z9.string().nullish(),
-        gcsUri: z9.string().nullish(),
-        mimeType: z9.string().nullish()
-      })
-    ).nullish(),
-    raiMediaFilteredCount: z9.number().nullish()
-  }).nullish()
-});
-var googleVertexVideoModelOptionsSchema = lazySchema(
-  () => zodSchema(
+var vertexOperationSchema = lazySchema9(
+  () => zodSchema9(
+    z9.object({
+      name: z9.string().nullish(),
+      done: z9.boolean().nullish(),
+      error: z9.object({
+        code: z9.number().nullish(),
+        message: z9.string(),
+        status: z9.string().nullish()
+      }).nullish(),
+      response: z9.object({
+        videos: z9.array(
+          z9.object({
+            bytesBase64Encoded: z9.string().nullish(),
+            gcsUri: z9.string().nullish(),
+            mimeType: z9.string().nullish()
+          })
+        ).nullish(),
+        raiMediaFilteredCount: z9.number().nullish()
+      }).nullish()
+    })
+  )
+);
+var googleVertexVideoModelOptionsSchema = lazySchema9(
+  () => zodSchema9(
     z9.object({
       pollIntervalMs: z9.number().positive().nullish(),
       pollTimeoutMs: z9.number().positive().nullish(),