@ai-sdk/google-vertex 5.0.0-beta.11 → 5.0.0-beta.112

package/dist/index.js

@@ -1,92 +1,80 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  VERSION: () => VERSION,
-  createVertex: () => createVertex2,
-  vertex: () => vertex
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/google-vertex-provider-node.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+// src/google-vertex-provider.ts
+import { loadOptionalSetting as loadOptionalSetting2, resolve as resolve6 } from "@ai-sdk/provider-utils";
 
 // src/google-vertex-auth-google-auth-library.ts
-var import_google_auth_library = require("google-auth-library");
-var authInstance = null;
-var authOptions = null;
-function getAuth(options) {
-  if (!authInstance || options !== authOptions) {
-    authInstance = new import_google_auth_library.GoogleAuth({
-      scopes: ["https://www.googleapis.com/auth/cloud-platform"],
-      ...options
-    });
-    authOptions = options;
-  }
-  return authInstance;
-}
-async function generateAuthToken(options) {
-  const auth = getAuth(options || {});
-  const client = await auth.getClient();
-  const token = await client.getAccessToken();
-  return (token == null ? void 0 : token.token) || null;
+import { GoogleAuth } from "google-auth-library";
+function createAuthTokenGenerator(options) {
+  const auth = new GoogleAuth({
+    scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+    ...options
+  });
+  return async function generateAuthToken() {
+    var _a;
+    const client = await auth.getClient();
+    const token = await client.getAccessToken();
+    return (_a = token == null ? void 0 : token.token) != null ? _a : null;
+  };
 }
 
-// src/google-vertex-provider.ts
-var import_internal3 = require("@ai-sdk/google/internal");
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+// src/google-vertex-provider-base.ts
+import {
+  GoogleLanguageModel as GoogleLanguageModel2,
+  GoogleSpeechModel
+} from "@ai-sdk/google/internal";
+import {
+  generateId,
+  loadOptionalSetting,
+  loadSetting,
+  normalizeHeaders,
+  resolve as resolve5,
+  withoutTrailingSlash,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "5.0.0-beta.11" : "0.0.0-test";
+var VERSION = true ? "5.0.0-beta.112" : "0.0.0-test";
 
 // src/google-vertex-embedding-model.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
+import {
+  TooManyEmbeddingValuesForCallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createJsonResponseHandler,
+  postJsonToApi,
+  resolve,
+  parseProviderOptions,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
 
 // src/google-vertex-error.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_v4 = require("zod/v4");
-var googleVertexErrorDataSchema = import_v4.z.object({
-  error: import_v4.z.object({
-    code: import_v4.z.number().nullable(),
-    message: import_v4.z.string(),
-    status: import_v4.z.string()
+import { 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 googleVertexFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)(
+var googleVertexFailedResponseHandler = createJsonErrorResponseHandler(
   {
     errorSchema: googleVertexErrorDataSchema,
     errorToMessage: (data) => data.error.message
   }
 );
 
-// src/google-vertex-embedding-options.ts
-var import_v42 = require("zod/v4");
-var googleVertexEmbeddingModelOptions = import_v42.z.object({
+// src/google-vertex-embedding-model-options.ts
+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: import_v42.z.number().optional(),
+  outputDimensionality: z2.number().optional(),
   /**
    * Optional. Specifies the task type for generating embeddings.
    * Supported task types:
@@ -99,7 +87,7 @@ var googleVertexEmbeddingModelOptions = import_v42.z.object({
    * - FACT_VERIFICATION: Optimized for verifying factual information.
    * - CODE_RETRIEVAL_QUERY: Optimized for retrieving code blocks based on natural language queries.
    */
-  taskType: import_v42.z.enum([
+  taskType: z2.enum([
     "SEMANTIC_SIMILARITY",
     "CLASSIFICATION",
     "CLUSTERING",
@@ -114,39 +102,60 @@ var googleVertexEmbeddingModelOptions = import_v42.z.object({
    * Only valid when task_type is set to 'RETRIEVAL_DOCUMENT'.
    * Helps the model produce better embeddings by providing additional context.
    */
-  title: import_v42.z.string().optional(),
+  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: import_v42.z.boolean().optional()
+  autoTruncate: z2.boolean().optional()
 });
 
 // src/google-vertex-embedding-model.ts
-var GoogleVertexEmbeddingModel = class {
+var GoogleVertexEmbeddingModel = class _GoogleVertexEmbeddingModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
-    this.maxEmbeddingsPerCall = 2048;
     this.supportsParallelCalls = true;
     this.modelId = modelId;
     this.config = config;
   }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _GoogleVertexEmbeddingModel(options.modelId, options.config);
+  }
   get provider() {
     return this.config.provider;
   }
+  // gemini-embedding-2 models only support :embedContent (one value per call),
+  // not the :predict batch endpoint. https://github.com/vercel/ai/issues/15853
+  get maxEmbeddingsPerCall() {
+    return usesEmbedContentEndpoint(this.modelId) ? 1 : 2048;
+  }
   async doEmbed({
     values,
     headers,
     abortSignal,
     providerOptions
   }) {
-    let googleOptions = await (0, import_provider_utils2.parseProviderOptions)({
-      provider: "vertex",
+    var _a;
+    let googleOptions = await parseProviderOptions({
+      provider: "googleVertex",
       providerOptions,
       schema: googleVertexEmbeddingModelOptions
     });
     if (googleOptions == null) {
-      googleOptions = await (0, import_provider_utils2.parseProviderOptions)({
+      googleOptions = await parseProviderOptions({
+        provider: "vertex",
+        providerOptions,
+        schema: googleVertexEmbeddingModelOptions
+      });
+    }
+    if (googleOptions == null) {
+      googleOptions = await parseProviderOptions({
         provider: "google",
         providerOptions,
         schema: googleVertexEmbeddingModelOptions
@@ -154,23 +163,54 @@ var GoogleVertexEmbeddingModel = class {
     }
     googleOptions = googleOptions != null ? googleOptions : {};
     if (values.length > this.maxEmbeddingsPerCall) {
-      throw new import_provider.TooManyEmbeddingValuesForCallError({
+      throw new TooManyEmbeddingValuesForCallError({
         provider: this.provider,
         modelId: this.modelId,
         maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
         values
       });
     }
-    const mergedHeaders = (0, import_provider_utils2.combineHeaders)(
-      await (0, import_provider_utils2.resolve)(this.config.headers),
+    const mergedHeaders = combineHeaders(
+      this.config.headers ? await resolve(this.config.headers) : void 0,
       headers
     );
+    if (usesEmbedContentEndpoint(this.modelId)) {
+      const {
+        responseHeaders: responseHeaders2,
+        value: response2,
+        rawValue: rawValue2
+      } = await postJsonToApi({
+        url: `${this.config.baseURL}/models/${this.modelId}:embedContent`,
+        headers: mergedHeaders,
+        body: {
+          content: { parts: [{ text: values[0] }] },
+          embedContentConfig: {
+            outputDimensionality: googleOptions.outputDimensionality,
+            taskType: googleOptions.taskType,
+            title: googleOptions.title,
+            autoTruncate: googleOptions.autoTruncate
+          }
+        },
+        failedResponseHandler: googleVertexFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(
+          googleVertexEmbedContentResponseSchema
+        ),
+        abortSignal,
+        fetch: this.config.fetch
+      });
+      return {
+        warnings: [],
+        embeddings: [response2.embedding.values],
+        usage: ((_a = response2.usageMetadata) == null ? void 0 : _a.promptTokenCount) == null ? void 0 : { tokens: response2.usageMetadata.promptTokenCount },
+        response: { headers: responseHeaders2, body: rawValue2 }
+      };
+    }
     const url = `${this.config.baseURL}/models/${this.modelId}:predict`;
     const {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils2.postJsonToApi)({
+    } = await postJsonToApi({
       url,
       headers: mergedHeaders,
       body: {
@@ -185,7 +225,7 @@ var GoogleVertexEmbeddingModel = class {
         }
       },
       failedResponseHandler: googleVertexFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         googleVertexTextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -206,29 +246,122 @@ var GoogleVertexEmbeddingModel = class {
     };
   }
 };
-var googleVertexTextEmbeddingResponseSchema = import_v43.z.object({
-  predictions: import_v43.z.array(
-    import_v43.z.object({
-      embeddings: import_v43.z.object({
-        values: import_v43.z.array(import_v43.z.number()),
-        statistics: import_v43.z.object({
-          token_count: import_v43.z.number()
+var googleVertexTextEmbeddingResponseSchema = z3.object({
+  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()
+});
+function usesEmbedContentEndpoint(modelId) {
+  return modelId === "gemini-embedding-2" || modelId === "gemini-embedding-2-preview";
+}
+
+// src/google-vertex-image-model.ts
+import { GoogleLanguageModel } from "@ai-sdk/google/internal";
+import {
+  combineHeaders as combineHeaders2,
+  convertToBase64,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  generateId as defaultGenerateId,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi as postJsonToApi2,
+  resolve as resolve2,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
+
+// src/google-vertex-image-model-options.ts
+import { z as z4 } from "zod/v4";
+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()
+});
 
 // src/google-vertex-image-model.ts
-var import_internal = require("@ai-sdk/google/internal");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v44 = require("zod/v4");
-var GoogleVertexImageModel = class {
+var GoogleVertexImageModel = class _GoogleVertexImageModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
     this.specificationVersion = "v4";
   }
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE2](options) {
+    return new _GoogleVertexImageModel(options.modelId, options.config);
+  }
   get maxImagesPerCall() {
     if (isGeminiModel(this.modelId)) {
       return 10;
@@ -256,7 +389,7 @@ var GoogleVertexImageModel = class {
     files,
     mask
   }) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f;
     const warnings = [];
     if (size != null) {
       warnings.push({
@@ -265,12 +398,16 @@ var GoogleVertexImageModel = class {
         details: "This model does not support the `size` option. Use `aspectRatio` instead."
       });
     }
-    const vertexImageOptions = await (0, import_provider_utils3.parseProviderOptions)({
+    const googleVertexImageOptions = (_a = await parseProviderOptions2({
+      provider: "googleVertex",
+      providerOptions,
+      schema: googleVertexImageModelOptionsSchema
+    })) != null ? _a : await parseProviderOptions2({
       provider: "vertex",
       providerOptions,
       schema: googleVertexImageModelOptionsSchema
     });
-    const { edit, ...otherOptions } = vertexImageOptions != null ? vertexImageOptions : {};
+    const { edit, ...otherOptions } = googleVertexImageOptions != null ? googleVertexImageOptions : {};
     const { mode: editMode, baseSteps, maskMode, maskDilation } = edit != null ? edit : {};
     const isEditMode = files != null && files.length > 0;
     let body;
@@ -326,39 +463,44 @@ var GoogleVertexImageModel = class {
         }
       };
     }
-    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
-    const { value: response, responseHeaders } = await (0, import_provider_utils3.postJsonToApi)({
+    const currentDate = (_d = (_c = (_b = this.config._internal) == null ? void 0 : _b.currentDate) == null ? void 0 : _c.call(_b)) != null ? _d : /* @__PURE__ */ new Date();
+    const { value: response, responseHeaders } = await postJsonToApi2({
       url: `${this.config.baseURL}/models/${this.modelId}:predict`,
-      headers: (0, import_provider_utils3.combineHeaders)(await (0, import_provider_utils3.resolve)(this.config.headers), headers),
+      headers: combineHeaders2(
+        this.config.headers ? await resolve2(this.config.headers) : void 0,
+        headers
+      ),
       body,
       failedResponseHandler: googleVertexFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
-        vertexImageResponseSchema
+      successfulResponseHandler: createJsonResponseHandler2(
+        googleVertexImageResponseSchema
       ),
       abortSignal,
       fetch: this.config.fetch
     });
     return {
-      images: (_e = (_d = response.predictions) == null ? void 0 : _d.map(
+      images: (_f = (_e = response.predictions) == null ? void 0 : _e.map(
         ({ bytesBase64Encoded }) => bytesBase64Encoded
-      )) != null ? _e : [],
+      )) != null ? _f : [],
       warnings,
       response: {
         timestamp: currentDate,
         modelId: this.modelId,
         headers: responseHeaders
       },
-      providerMetadata: {
-        vertex: {
-          images: (_g = (_f = response.predictions) == null ? void 0 : _f.map((prediction) => {
+      providerMetadata: (() => {
+        var _a2, _b2;
+        const payload = {
+          images: (_b2 = (_a2 = response.predictions) == null ? void 0 : _a2.map((prediction) => {
             const {
               // normalize revised prompt property
               prompt: revisedPrompt
             } = prediction;
             return { ...revisedPrompt != null && { revisedPrompt } };
-          })) != null ? _g : []
-        }
-      }
+          })) != null ? _b2 : []
+        };
+        return { googleVertex: payload, vertex: payload };
+      })()
     };
   }
   async doGenerateGemini({
@@ -401,13 +543,16 @@ var GoogleVertexImageModel = class {
         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
           });
         }
@@ -416,27 +561,30 @@ var GoogleVertexImageModel = class {
     const languageModelPrompt = [
       { role: "user", content: userContent }
     ];
-    const languageModel = new import_internal.GoogleGenerativeAILanguageModel(this.modelId, {
+    const languageModel = new GoogleLanguageModel(this.modelId, {
       provider: this.config.provider,
       baseURL: this.config.baseURL,
       headers: (_a = this.config.headers) != null ? _a : {},
       fetch: this.config.fetch,
-      generateId: (_b = this.config.generateId) != null ? _b : import_provider_utils3.generateId,
+      generateId: (_b = this.config.generateId) != null ? _b : defaultGenerateId,
       supportedUrls: () => ({
         "*": [/^https?:\/\/.*$/, /^gs:\/\/.*$/]
       })
     });
+    const userVertexOptions = (_c = providerOptions == null ? void 0 : providerOptions.googleVertex) != null ? _c : providerOptions == null ? void 0 : providerOptions.vertex;
+    const innerVertexOptions = {
+      responseModalities: ["IMAGE"],
+      imageConfig: aspectRatio ? {
+        aspectRatio
+      } : void 0,
+      ...userVertexOptions != null ? userVertexOptions : {}
+    };
     const result = await languageModel.doGenerate({
       prompt: languageModelPrompt,
       seed,
       providerOptions: {
-        vertex: {
-          responseModalities: ["IMAGE"],
-          imageConfig: aspectRatio ? {
-            aspectRatio
-          } : void 0,
-          ...(_c = providerOptions == null ? void 0 : providerOptions.vertex) != null ? _c : {}
-        }
+        googleVertex: innerVertexOptions,
+        vertex: innerVertexOptions
       },
       headers,
       abortSignal
@@ -444,17 +592,19 @@ var GoogleVertexImageModel = class {
     const currentDate = (_f = (_e = (_d = this.config._internal) == null ? void 0 : _d.currentDate) == null ? void 0 : _e.call(_d)) != null ? _f : /* @__PURE__ */ new Date();
     const images = [];
     for (const part of result.content) {
-      if (part.type === "file" && part.mediaType.startsWith("image/")) {
-        images.push((0, import_provider_utils3.convertToBase64)(part.data));
+      if (part.type === "file" && part.mediaType.startsWith("image/") && part.data.type === "data") {
+        images.push(convertToBase64(part.data.data));
       }
     }
+    const geminiPayload = {
+      images: images.map(() => ({}))
+    };
     return {
       images,
       warnings,
       providerMetadata: {
-        vertex: {
-          images: images.map(() => ({}))
-        }
+        googleVertex: geminiPayload,
+        vertex: geminiPayload
       },
       response: {
         timestamp: currentDate,
@@ -472,71 +622,15 @@ var GoogleVertexImageModel = class {
 function isGeminiModel(modelId) {
   return modelId.startsWith("gemini-");
 }
-var vertexImageResponseSchema = import_v44.z.object({
-  predictions: import_v44.z.array(
-    import_v44.z.object({
-      bytesBase64Encoded: import_v44.z.string(),
-      mimeType: import_v44.z.string(),
-      prompt: import_v44.z.string().nullish()
+var googleVertexImageResponseSchema = z5.object({
+  predictions: z5.array(
+    z5.object({
+      bytesBase64Encoded: z5.string(),
+      mimeType: z5.string(),
+      prompt: z5.string().nullish()
     })
   ).nullish()
 });
-var googleVertexImageModelOptionsSchema = import_v44.z.object({
-  negativePrompt: import_v44.z.string().nullish(),
-  personGeneration: import_v44.z.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-  safetySetting: import_v44.z.enum([
-    "block_low_and_above",
-    "block_medium_and_above",
-    "block_only_high",
-    "block_none"
-  ]).nullish(),
-  addWatermark: import_v44.z.boolean().nullish(),
-  storageUri: import_v44.z.string().nullish(),
-  sampleImageSize: import_v44.z.enum(["1K", "2K"]).nullish(),
-  /**
-   * Configuration for image editing operations
-   */
-  edit: import_v44.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: import_v44.z.number().nullish(),
-    // Edit mode options
-    // https://cloud.google.com/vertex-ai/generative-ai/docs/image/edit-insert-objects
-    mode: import_v44.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: import_v44.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: import_v44.z.number().nullish()
-  }).nullish()
-});
 function getBase64Data(file) {
   if (file.type === "url") {
     throw new Error(
@@ -546,25 +640,250 @@ function getBase64Data(file) {
   if (typeof file.data === "string") {
     return file.data;
   }
-  return (0, import_provider_utils3.convertUint8ArrayToBase64)(file.data);
+  return convertUint8ArrayToBase64(file.data);
 }
 
 // src/google-vertex-tools.ts
-var import_internal2 = require("@ai-sdk/google/internal");
+import { googleTools } from "@ai-sdk/google/internal";
 var googleVertexTools = {
-  googleSearch: import_internal2.googleTools.googleSearch,
-  enterpriseWebSearch: import_internal2.googleTools.enterpriseWebSearch,
-  googleMaps: import_internal2.googleTools.googleMaps,
-  urlContext: import_internal2.googleTools.urlContext,
-  fileSearch: import_internal2.googleTools.fileSearch,
-  codeExecution: import_internal2.googleTools.codeExecution,
-  vertexRagStore: import_internal2.googleTools.vertexRagStore
+  googleSearch: googleTools.googleSearch,
+  enterpriseWebSearch: googleTools.enterpriseWebSearch,
+  googleMaps: googleTools.googleMaps,
+  urlContext: googleTools.urlContext,
+  fileSearch: googleTools.fileSearch,
+  codeExecution: googleTools.codeExecution,
+  vertexRagStore: googleTools.vertexRagStore
+};
+
+// src/google-vertex-transcription-model.ts
+import {
+  combineHeaders as combineHeaders3,
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi3,
+  resolve as resolve3,
+  serializeModelOptions as serializeModelOptions3,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3
+} from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
+
+// src/google-vertex-transcription-model-options.ts
+import { z as z6 } from "zod/v4";
+var googleVertexTranscriptionProviderOptionsSchema = z6.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: z6.array(z6.string()).optional(),
+  /**
+   * Whether to add punctuation to the transcript. Defaults to `true`.
+   */
+  enableAutomaticPunctuation: z6.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: z6.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: z6.string().optional()
+});
+
+// src/google-vertex-transcription-model.ts
+function parseDurationSeconds(value) {
+  if (value == null) {
+    return void 0;
+  }
+  const seconds = Number.parseFloat(value);
+  return Number.isFinite(seconds) ? seconds : void 0;
+}
+function convertBcp47ToIso6391(value) {
+  if (value == null) {
+    return void 0;
+  }
+  try {
+    const language = new Intl.Locale(value).language;
+    return language.length === 2 ? language : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+var GoogleVertexTranscriptionModel = class _GoogleVertexTranscriptionModel {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  static [WORKFLOW_SERIALIZE3](model) {
+    return serializeModelOptions3({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE3](options) {
+    return new _GoogleVertexTranscriptionModel(options.modelId, options.config);
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const warnings = [];
+    let googleOptions;
+    for (const provider of ["googleVertex", "vertex", "google"]) {
+      googleOptions = await parseProviderOptions3({
+        provider,
+        providerOptions: options.providerOptions,
+        schema: googleVertexTranscriptionProviderOptionsSchema
+      });
+      if (googleOptions != null) {
+        break;
+      }
+    }
+    const region = (_d = googleOptions == null ? void 0 : googleOptions.region) != null ? _d : this.config.location;
+    const languageCodes = (_e = googleOptions == null ? void 0 : googleOptions.languageCodes) != null ? _e : ["auto"];
+    const content = typeof options.audio === "string" ? options.audio : convertUint8ArrayToBase642(options.audio);
+    const requestBody = {
+      config: {
+        model: this.modelId,
+        languageCodes,
+        // Let Speech-to-Text auto-detect the audio encoding (wav/mp3/flac/…).
+        autoDecodingConfig: {},
+        features: {
+          // Word timing populates `segments`.
+          enableWordTimeOffsets: (_f = googleOptions == null ? void 0 : googleOptions.enableWordTimeOffsets) != null ? _f : true,
+          enableAutomaticPunctuation: (_g = googleOptions == null ? void 0 : googleOptions.enableAutomaticPunctuation) != null ? _g : true
+        }
+      },
+      content
+    };
+    const host = region === "global" ? "speech.googleapis.com" : `${region}-speech.googleapis.com`;
+    const url = `https://${host}/v2/projects/${this.config.project}/locations/${region}/recognizers/_:recognize`;
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postJsonToApi3({
+      url,
+      headers: combineHeaders3(
+        this.config.headers ? await resolve3(this.config.headers) : void 0,
+        options.headers
+      ),
+      body: requestBody,
+      failedResponseHandler: googleVertexFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler3(
+        googleVertexTranscriptionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const results = (_h = response.results) != null ? _h : [];
+    const text = results.map((result) => {
+      var _a2, _b2, _c2;
+      return (_c2 = (_b2 = (_a2 = result.alternatives) == null ? void 0 : _a2[0]) == null ? void 0 : _b2.transcript) != null ? _c2 : "";
+    }).join(" ").trim();
+    const segments = results.flatMap(
+      (result) => {
+        var _a2, _b2, _c2, _d2;
+        return (_d2 = (_c2 = (_b2 = (_a2 = result.alternatives) == null ? void 0 : _a2[0]) == null ? void 0 : _b2.words) == null ? void 0 : _c2.flatMap((word) => {
+          const startSecond = parseDurationSeconds(word.startOffset);
+          const endSecond = parseDurationSeconds(word.endOffset);
+          return word.word == null || startSecond == null || endSecond == null ? [] : [{ text: word.word, startSecond, endSecond }];
+        })) != null ? _d2 : [];
+      }
+    );
+    const language = convertBcp47ToIso6391((_i = results[0]) == null ? void 0 : _i.languageCode);
+    return {
+      text,
+      segments,
+      language,
+      durationInSeconds: parseDurationSeconds(
+        (_j = response.metadata) == null ? void 0 : _j.totalBilledDuration
+      ),
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      }
+    };
+  }
 };
+var googleVertexTranscriptionResponseSchema = z7.object({
+  results: z7.array(
+    z7.object({
+      alternatives: z7.array(
+        z7.object({
+          transcript: z7.string().nullish(),
+          words: z7.array(
+            z7.object({
+              word: z7.string().nullish(),
+              startOffset: z7.string().nullish(),
+              endOffset: z7.string().nullish()
+            })
+          ).nullish()
+        })
+      ).nullish(),
+      languageCode: z7.string().nullish()
+    })
+  ).nullish(),
+  metadata: z7.object({
+    totalBilledDuration: z7.string().nullish()
+  }).nullish()
+});
+
+// src/google-vertex-video-model.ts
+import {
+  AISDKError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders4,
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase643,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  delay,
+  parseProviderOptions as parseProviderOptions4,
+  postJsonToApi as postJsonToApi4,
+  resolve as resolve4
+} from "@ai-sdk/provider-utils";
+import { z as z9 } from "zod/v4";
+
+// src/google-vertex-video-model-options.ts
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var googleVertexVideoModelOptionsSchema = lazySchema(
+  () => zodSchema(
+    z8.object({
+      pollIntervalMs: z8.number().positive().nullish(),
+      pollTimeoutMs: z8.number().positive().nullish(),
+      personGeneration: z8.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+      negativePrompt: z8.string().nullish(),
+      generateAudio: z8.boolean().nullish(),
+      gcsOutputDirectory: z8.string().nullish(),
+      referenceImages: z8.array(
+        z8.object({
+          bytesBase64Encoded: z8.string().nullish(),
+          gcsUri: z8.string().nullish()
+        })
+      ).nullish()
+    }).passthrough()
+  )
+);
 
 // src/google-vertex-video-model.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
 var GoogleVertexVideoModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -578,10 +897,14 @@ var GoogleVertexVideoModel = class {
     return 4;
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
     const warnings = [];
-    const vertexOptions = await (0, import_provider_utils4.parseProviderOptions)({
+    const googleVertexOptions = (_d = await parseProviderOptions4({
+      provider: "googleVertex",
+      providerOptions: options.providerOptions,
+      schema: googleVertexVideoModelOptionsSchema
+    })) != null ? _d : await parseProviderOptions4({
       provider: "vertex",
       providerOptions: options.providerOptions,
       schema: googleVertexVideoModelOptionsSchema
@@ -599,15 +922,15 @@ var GoogleVertexVideoModel = class {
           details: "Vertex AI video models require base64-encoded images or GCS URIs. URL will be ignored."
         });
       } else {
-        const base64Data = typeof options.image.data === "string" ? options.image.data : (0, import_provider_utils4.convertUint8ArrayToBase64)(options.image.data);
+        const base64Data = typeof options.image.data === "string" ? options.image.data : convertUint8ArrayToBase643(options.image.data);
         instance.image = {
           bytesBase64Encoded: base64Data,
           mimeType: options.image.mediaType
         };
       }
     }
-    if ((vertexOptions == null ? void 0 : vertexOptions.referenceImages) != null) {
-      instance.referenceImages = vertexOptions.referenceImages;
+    if ((googleVertexOptions == null ? void 0 : googleVertexOptions.referenceImages) != null) {
+      instance.referenceImages = googleVertexOptions.referenceImages;
     }
     const parameters = {
       sampleCount: options.n
@@ -629,17 +952,18 @@ var GoogleVertexVideoModel = class {
     if (options.seed) {
       parameters.seed = options.seed;
     }
-    if (vertexOptions != null) {
-      const opts = vertexOptions;
+    const generateAudio = (_e = options.generateAudio) != null ? _e : googleVertexOptions == null ? void 0 : googleVertexOptions.generateAudio;
+    if (generateAudio != null) {
+      parameters.generateAudio = generateAudio;
+    }
+    if (googleVertexOptions != null) {
+      const opts = googleVertexOptions;
       if (opts.personGeneration !== void 0 && opts.personGeneration !== null) {
         parameters.personGeneration = opts.personGeneration;
       }
       if (opts.negativePrompt !== void 0 && opts.negativePrompt !== null) {
         parameters.negativePrompt = opts.negativePrompt;
       }
-      if (opts.generateAudio !== void 0 && opts.generateAudio !== null) {
-        parameters.generateAudio = opts.generateAudio;
-      }
       if (opts.gcsOutputDirectory !== void 0 && opts.gcsOutputDirectory !== null) {
         parameters.gcsOutputDirectory = opts.gcsOutputDirectory;
       }
@@ -657,18 +981,18 @@ var GoogleVertexVideoModel = class {
         }
       }
     }
-    const { value: operation } = await (0, import_provider_utils4.postJsonToApi)({
+    const { value: operation } = await postJsonToApi4({
       url: `${this.config.baseURL}/models/${this.modelId}:predictLongRunning`,
-      headers: (0, import_provider_utils4.combineHeaders)(
-        await (0, import_provider_utils4.resolve)(this.config.headers),
+      headers: combineHeaders4(
+        await resolve4(this.config.headers),
         options.headers
       ),
       body: {
         instances,
         parameters
       },
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
-        vertexOperationSchema
+      successfulResponseHandler: createJsonResponseHandler4(
+        googleVertexOperationSchema
       ),
       failedResponseHandler: googleVertexFailedResponseHandler,
       abortSignal: options.abortSignal,
@@ -676,41 +1000,41 @@ var GoogleVertexVideoModel = class {
     });
     const operationName = operation.name;
     if (!operationName) {
-      throw new import_provider2.AISDKError({
+      throw new AISDKError({
         name: "VERTEX_VIDEO_GENERATION_ERROR",
         message: "No operation name returned from API"
       });
     }
-    const pollIntervalMs = (_d = vertexOptions == null ? void 0 : vertexOptions.pollIntervalMs) != null ? _d : 1e4;
-    const pollTimeoutMs = (_e = vertexOptions == null ? void 0 : vertexOptions.pollTimeoutMs) != null ? _e : 6e5;
+    const pollIntervalMs = (_f = googleVertexOptions == null ? void 0 : googleVertexOptions.pollIntervalMs) != null ? _f : 1e4;
+    const pollTimeoutMs = (_g = googleVertexOptions == null ? void 0 : googleVertexOptions.pollTimeoutMs) != null ? _g : 6e5;
     const startTime = Date.now();
     let finalOperation = operation;
     let responseHeaders;
     while (!finalOperation.done) {
       if (Date.now() - startTime > pollTimeoutMs) {
-        throw new import_provider2.AISDKError({
+        throw new AISDKError({
           name: "VERTEX_VIDEO_GENERATION_TIMEOUT",
           message: `Video generation timed out after ${pollTimeoutMs}ms`
         });
       }
-      await (0, import_provider_utils4.delay)(pollIntervalMs);
-      if ((_f = options.abortSignal) == null ? void 0 : _f.aborted) {
-        throw new import_provider2.AISDKError({
+      await delay(pollIntervalMs);
+      if ((_h = options.abortSignal) == null ? void 0 : _h.aborted) {
+        throw new AISDKError({
           name: "VERTEX_VIDEO_GENERATION_ABORTED",
           message: "Video generation request was aborted"
         });
       }
-      const { value: statusOperation, responseHeaders: pollHeaders } = await (0, import_provider_utils4.postJsonToApi)({
+      const { value: statusOperation, responseHeaders: pollHeaders } = await postJsonToApi4({
         url: `${this.config.baseURL}/models/${this.modelId}:fetchPredictOperation`,
-        headers: (0, import_provider_utils4.combineHeaders)(
-          await (0, import_provider_utils4.resolve)(this.config.headers),
+        headers: combineHeaders4(
+          await resolve4(this.config.headers),
           options.headers
         ),
         body: {
           operationName
         },
-        successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
-          vertexOperationSchema
+        successfulResponseHandler: createJsonResponseHandler4(
+          googleVertexOperationSchema
         ),
         failedResponseHandler: googleVertexFailedResponseHandler,
         abortSignal: options.abortSignal,
@@ -720,14 +1044,14 @@ var GoogleVertexVideoModel = class {
       responseHeaders = pollHeaders;
     }
     if (finalOperation.error) {
-      throw new import_provider2.AISDKError({
+      throw new AISDKError({
         name: "VERTEX_VIDEO_GENERATION_FAILED",
         message: `Video generation failed: ${finalOperation.error.message}`
       });
     }
     const response = finalOperation.response;
     if (!(response == null ? void 0 : response.videos) || response.videos.length === 0) {
-      throw new import_provider2.AISDKError({
+      throw new AISDKError({
         name: "VERTEX_VIDEO_GENERATION_ERROR",
         message: `No videos in response. Response: ${JSON.stringify(finalOperation)}`
       });
@@ -757,7 +1081,7 @@ var GoogleVertexVideoModel = class {
       }
     }
     if (videos.length === 0) {
-      throw new import_provider2.AISDKError({
+      throw new AISDKError({
         name: "VERTEX_VIDEO_GENERATION_ERROR",
         message: "No valid videos in response"
       });
@@ -770,78 +1094,64 @@ var GoogleVertexVideoModel = class {
         modelId: this.modelId,
         headers: responseHeaders
       },
-      providerMetadata: {
-        "google-vertex": {
-          videos: videoMetadata
-        }
-      }
+      providerMetadata: /* @__PURE__ */ (() => {
+        const payload = { videos: videoMetadata };
+        return {
+          googleVertex: payload,
+          // Legacy keys preserved for backward compatibility.
+          "google-vertex": payload,
+          vertex: payload
+        };
+      })()
     };
   }
 };
-var vertexOperationSchema = import_v45.z.object({
-  name: import_v45.z.string().nullish(),
-  done: import_v45.z.boolean().nullish(),
-  error: import_v45.z.object({
-    code: import_v45.z.number().nullish(),
-    message: import_v45.z.string(),
-    status: import_v45.z.string().nullish()
+var googleVertexOperationSchema = 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: import_v45.z.object({
-    videos: import_v45.z.array(
-      import_v45.z.object({
-        bytesBase64Encoded: import_v45.z.string().nullish(),
-        gcsUri: import_v45.z.string().nullish(),
-        mimeType: import_v45.z.string().nullish()
+  response: z9.object({
+    videos: z9.array(
+      z9.object({
+        bytesBase64Encoded: z9.string().nullish(),
+        gcsUri: z9.string().nullish(),
+        mimeType: z9.string().nullish()
       })
     ).nullish(),
-    raiMediaFilteredCount: import_v45.z.number().nullish()
+    raiMediaFilteredCount: z9.number().nullish()
   }).nullish()
 });
-var googleVertexVideoModelOptionsSchema = (0, import_provider_utils4.lazySchema)(
-  () => (0, import_provider_utils4.zodSchema)(
-    import_v45.z.object({
-      pollIntervalMs: import_v45.z.number().positive().nullish(),
-      pollTimeoutMs: import_v45.z.number().positive().nullish(),
-      personGeneration: import_v45.z.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-      negativePrompt: import_v45.z.string().nullish(),
-      generateAudio: import_v45.z.boolean().nullish(),
-      gcsOutputDirectory: import_v45.z.string().nullish(),
-      referenceImages: import_v45.z.array(
-        import_v45.z.object({
-          bytesBase64Encoded: import_v45.z.string().nullish(),
-          gcsUri: import_v45.z.string().nullish()
-        })
-      ).nullish()
-    }).passthrough()
-  )
-);
 
-// src/google-vertex-provider.ts
+// src/google-vertex-provider-base.ts
 var EXPRESS_MODE_BASE_URL = "https://aiplatform.googleapis.com/v1/publishers/google";
 function createExpressModeFetch(apiKey, customFetch) {
   return async (url, init) => {
     const modifiedInit = {
       ...init,
       headers: {
-        ...(init == null ? void 0 : init.headers) ? (0, import_provider_utils5.normalizeHeaders)(init.headers) : {},
+        ...(init == null ? void 0 : init.headers) ? normalizeHeaders(init.headers) : {},
         "x-goog-api-key": apiKey
       }
     };
     return (customFetch != null ? customFetch : fetch)(url.toString(), modifiedInit);
   };
 }
-function createVertex(options = {}) {
-  const apiKey = (0, import_provider_utils5.loadOptionalSetting)({
+function createGoogleVertex(options = {}) {
+  const apiKey = loadOptionalSetting({
     settingValue: options.apiKey,
     environmentVariableName: "GOOGLE_VERTEX_API_KEY"
   });
-  const loadVertexProject = () => (0, import_provider_utils5.loadSetting)({
+  const loadGoogleVertexProject = () => loadSetting({
     settingValue: options.project,
     settingName: "project",
     environmentVariableName: "GOOGLE_VERTEX_PROJECT",
     description: "Google Vertex project"
   });
-  const loadVertexLocation = () => (0, import_provider_utils5.loadSetting)({
+  const loadGoogleVertexLocation = () => loadSetting({
     settingValue: options.location,
     settingName: "location",
     environmentVariableName: "GOOGLE_VERTEX_LOCATION",
@@ -850,18 +1160,26 @@ function createVertex(options = {}) {
   const loadBaseURL = () => {
     var _a, _b;
     if (apiKey) {
-      return (_a = (0, import_provider_utils5.withoutTrailingSlash)(options.baseURL)) != null ? _a : EXPRESS_MODE_BASE_URL;
+      return (_a = withoutTrailingSlash(options.baseURL)) != null ? _a : EXPRESS_MODE_BASE_URL;
     }
-    const region = loadVertexLocation();
-    const project = loadVertexProject();
-    const baseHost = `${region === "global" ? "" : region + "-"}aiplatform.googleapis.com`;
-    return (_b = (0, import_provider_utils5.withoutTrailingSlash)(options.baseURL)) != null ? _b : `https://${baseHost}/v1beta1/projects/${project}/locations/${region}/publishers/google`;
+    const region = loadGoogleVertexLocation();
+    const project = loadGoogleVertexProject();
+    const getHost = () => {
+      if (region === "global") {
+        return "aiplatform.googleapis.com";
+      } else if (region === "eu" || region === "us") {
+        return `aiplatform.${region}.rep.googleapis.com`;
+      } else {
+        return `${region}-aiplatform.googleapis.com`;
+      }
+    };
+    return (_b = withoutTrailingSlash(options.baseURL)) != null ? _b : `https://${getHost()}/v1beta1/projects/${project}/locations/${region}/publishers/google`;
   };
   const createConfig = (name) => {
     const getHeaders = async () => {
       var _a;
-      const originalHeaders = await (0, import_provider_utils5.resolve)((_a = options.headers) != null ? _a : {});
-      return (0, import_provider_utils5.withUserAgentSuffix)(
+      const originalHeaders = await resolve5((_a = options.headers) != null ? _a : {});
+      return withUserAgentSuffix(
         originalHeaders,
         `ai-sdk/google-vertex/${VERSION}`
       );
@@ -875,9 +1193,9 @@ function createVertex(options = {}) {
   };
   const createChatModel = (modelId) => {
     var _a;
-    return new import_internal3.GoogleGenerativeAILanguageModel(modelId, {
+    return new GoogleLanguageModel2(modelId, {
       ...createConfig("chat"),
-      generateId: (_a = options.generateId) != null ? _a : import_provider_utils5.generateId,
+      generateId: (_a = options.generateId) != null ? _a : generateId,
       supportedUrls: () => ({
         "*": [
           // HTTP URLs:
@@ -893,14 +1211,30 @@ function createVertex(options = {}) {
     var _a;
     return new GoogleVertexImageModel(modelId, {
       ...createConfig("image"),
-      generateId: (_a = options.generateId) != null ? _a : import_provider_utils5.generateId
+      generateId: (_a = options.generateId) != null ? _a : generateId
     });
   };
   const createVideoModel = (modelId) => {
     var _a;
     return new GoogleVertexVideoModel(modelId, {
       ...createConfig("video"),
-      generateId: (_a = options.generateId) != null ? _a : import_provider_utils5.generateId
+      generateId: (_a = options.generateId) != null ? _a : generateId
+    });
+  };
+  const createSpeechModel = (modelId) => new GoogleSpeechModel(modelId, createConfig("speech"));
+  const createTranscriptionModel = (modelId) => {
+    if (apiKey) {
+      throw new Error(
+        "Google Vertex transcription models do not support Express Mode API keys. Use standard Google Cloud credentials instead."
+      );
+    }
+    const config = createConfig("transcription");
+    return new GoogleVertexTranscriptionModel(modelId, {
+      provider: config.provider,
+      headers: config.headers,
+      fetch: config.fetch,
+      project: loadGoogleVertexProject(),
+      location: loadGoogleVertexLocation()
     });
   };
   const provider = function(modelId) {
@@ -919,34 +1253,42 @@ function createVertex(options = {}) {
   provider.imageModel = createImageModel;
   provider.video = createVideoModel;
   provider.videoModel = createVideoModel;
+  provider.speech = createSpeechModel;
+  provider.speechModel = createSpeechModel;
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
   provider.tools = googleVertexTools;
   return provider;
 }
 
-// src/google-vertex-provider-node.ts
-function createVertex2(options = {}) {
-  const apiKey = (0, import_provider_utils6.loadOptionalSetting)({
+// src/google-vertex-provider.ts
+function createGoogleVertex2(options = {}) {
+  const apiKey = loadOptionalSetting2({
     settingValue: options.apiKey,
     environmentVariableName: "GOOGLE_VERTEX_API_KEY"
   });
   if (apiKey) {
-    return createVertex(options);
+    return createGoogleVertex(options);
   }
-  return createVertex({
+  const googleAuthOptions = options.project == null ? options.googleAuthOptions : {
+    projectId: options.project,
+    ...options.googleAuthOptions
+  };
+  const generateAuthToken = createAuthTokenGenerator(googleAuthOptions);
+  return createGoogleVertex({
     ...options,
     headers: async () => ({
-      Authorization: `Bearer ${await generateAuthToken(
-        options.googleAuthOptions
-      )}`,
-      ...await (0, import_provider_utils6.resolve)(options.headers)
+      Authorization: `Bearer ${await generateAuthToken()}`,
+      ...await resolve6(options.headers)
     })
   });
 }
-var vertex = createVertex2();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+var googleVertex = createGoogleVertex2();
+export {
   VERSION,
-  createVertex,
-  vertex
-});
+  createGoogleVertex2 as createGoogleVertex,
+  createGoogleVertex2 as createVertex,
+  googleVertex,
+  googleVertex as vertex
+};
 //# sourceMappingURL=index.js.map