@ai-sdk/google-vertex 5.0.98 → 5.0.99

package/dist/edge/index.js

@@ -1,1907 +1,1469 @@
-// src/edge/google-vertex-provider-edge.ts
-import { loadOptionalSetting as loadOptionalSetting3, resolve as resolve7 } from "@ai-sdk/provider-utils";
-
-// src/google-vertex-provider-base.ts
-import {
-  GoogleInteractionsLanguageModel,
-  GoogleLanguageModel as GoogleLanguageModel2,
-  GoogleSpeechModel
-} from "@ai-sdk/google/internal";
-import {
-  generateId,
-  loadOptionalSetting,
-  loadSetting,
-  normalizeHeaders,
-  resolve as resolve6,
-  withoutTrailingSlash,
-  withUserAgentSuffix
-} from "@ai-sdk/provider-utils";
-
-// src/version.ts
-var VERSION = true ? "5.0.98" : "0.0.0-test";
-
-// src/google-vertex-embedding-model.ts
-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
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, connectToWebSocket, convertBase64ToUint8Array, convertToBase64, convertUint8ArrayToBase64, createJsonErrorResponseHandler, createJsonResponseHandler, generateId, getRuntimeEnvironmentUserAgent, lazySchema, loadOptionalSetting, loadSetting, normalizeHeaders, parseProviderOptions, postJsonToApi, resolve, safeParseJSON, serializeModelOptions, waitForWebSocketBufferDrain, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
+import { GoogleInteractionsLanguageModel, GoogleLanguageModel, GoogleSpeechModel, googleTools } from "@ai-sdk/google/internal";
+import { AISDKError, InvalidArgumentError, TooManyEmbeddingValuesForCallError } from "@ai-sdk/provider";
 import { z } from "zod/v4";
-var googleVertexErrorDataSchema = z.object({
-  error: z.object({
-    code: z.number().nullable(),
-    message: z.string(),
-    status: z.string()
-  })
+//#region src/version.ts
+const VERSION = "5.0.99";
+//#endregion
+//#region src/google-vertex-error.ts
+const googleVertexErrorDataSchema = z.object({ error: z.object({
+	code: z.number().nullable(),
+	message: z.string(),
+	status: z.string()
+}) });
+const googleVertexFailedResponseHandler = createJsonErrorResponseHandler({
+	errorSchema: googleVertexErrorDataSchema,
+	errorToMessage: (data) => data.error.message
 });
-var googleVertexFailedResponseHandler = createJsonErrorResponseHandler(
-  {
-    errorSchema: googleVertexErrorDataSchema,
-    errorToMessage: (data) => data.error.message
-  }
-);
-
-// 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: 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()
+//#endregion
+//#region src/google-vertex-embedding-model-options.ts
+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(),
+	/**
+	* 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. 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()
 });
-
-// src/google-vertex-embedding-model.ts
-var GoogleVertexEmbeddingModel = class _GoogleVertexEmbeddingModel {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    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 : 250;
-  }
-  async doEmbed({
-    values,
-    headers,
-    abortSignal,
-    providerOptions
-  }) {
-    let googleOptions = await parseProviderOptions({
-      provider: "googleVertex",
-      providerOptions,
-      schema: googleVertexEmbeddingModelOptions
-    });
-    if (googleOptions == null) {
-      googleOptions = await parseProviderOptions({
-        provider: "vertex",
-        providerOptions,
-        schema: googleVertexEmbeddingModelOptions
-      });
-    }
-    if (googleOptions == null) {
-      googleOptions = await parseProviderOptions({
-        provider: "google",
-        providerOptions,
-        schema: googleVertexEmbeddingModelOptions
-      });
-    }
-    googleOptions = googleOptions ?? {};
-    if (values.length > this.maxEmbeddingsPerCall) {
-      throw new TooManyEmbeddingValuesForCallError({
-        provider: this.provider,
-        modelId: this.modelId,
-        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
-        values
-      });
-    }
-    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: response2.usageMetadata?.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 postJsonToApi({
-      url,
-      headers: mergedHeaders,
-      body: {
-        instances: values.map((value) => ({
-          content: value,
-          task_type: googleOptions.taskType,
-          title: googleOptions.title
-        })),
-        parameters: {
-          outputDimensionality: googleOptions.outputDimensionality,
-          autoTruncate: googleOptions.autoTruncate
-        }
-      },
-      failedResponseHandler: googleVertexFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        googleVertexTextEmbeddingResponseSchema
-      ),
-      abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      warnings: [],
-      embeddings: response.predictions.map(
-        (prediction) => prediction.embeddings.values
-      ),
-      usage: {
-        tokens: response.predictions.reduce(
-          (tokenCount, prediction) => tokenCount + prediction.embeddings.statistics.token_count,
-          0
-        )
-      },
-      response: { headers: responseHeaders, body: rawValue }
-    };
-  }
+//#endregion
+//#region src/google-vertex-embedding-model.ts
+var GoogleVertexEmbeddingModel = class GoogleVertexEmbeddingModel {
+	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;
+	}
+	get maxEmbeddingsPerCall() {
+		return usesEmbedContentEndpoint(this.modelId) ? 1 : 250;
+	}
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.supportsParallelCalls = true;
+		this.modelId = modelId;
+		this.config = config;
+	}
+	async doEmbed({ values, headers, abortSignal, providerOptions }) {
+		let googleOptions = await parseProviderOptions({
+			provider: "googleVertex",
+			providerOptions,
+			schema: googleVertexEmbeddingModelOptions
+		});
+		if (googleOptions == null) googleOptions = await parseProviderOptions({
+			provider: "vertex",
+			providerOptions,
+			schema: googleVertexEmbeddingModelOptions
+		});
+		if (googleOptions == null) googleOptions = await parseProviderOptions({
+			provider: "google",
+			providerOptions,
+			schema: googleVertexEmbeddingModelOptions
+		});
+		googleOptions = googleOptions ?? {};
+		if (values.length > this.maxEmbeddingsPerCall) throw new TooManyEmbeddingValuesForCallError({
+			provider: this.provider,
+			modelId: this.modelId,
+			maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+			values
+		});
+		const mergedHeaders = combineHeaders(this.config.headers ? await resolve(this.config.headers) : void 0, headers);
+		if (usesEmbedContentEndpoint(this.modelId)) {
+			const { responseHeaders, value: response, rawValue } = 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: [response.embedding.values],
+				usage: response.usageMetadata?.promptTokenCount == null ? void 0 : { tokens: response.usageMetadata.promptTokenCount },
+				response: {
+					headers: responseHeaders,
+					body: rawValue
+				}
+			};
+		}
+		const url = `${this.config.baseURL}/models/${this.modelId}:predict`;
+		const { responseHeaders, value: response, rawValue } = await postJsonToApi({
+			url,
+			headers: mergedHeaders,
+			body: {
+				instances: values.map((value) => ({
+					content: value,
+					task_type: googleOptions.taskType,
+					title: googleOptions.title
+				})),
+				parameters: {
+					outputDimensionality: googleOptions.outputDimensionality,
+					autoTruncate: googleOptions.autoTruncate
+				}
+			},
+			failedResponseHandler: googleVertexFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(googleVertexTextEmbeddingResponseSchema),
+			abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			warnings: [],
+			embeddings: response.predictions.map((prediction) => prediction.embeddings.values),
+			usage: { tokens: response.predictions.reduce((tokenCount, prediction) => tokenCount + prediction.embeddings.statistics.token_count, 0) },
+			response: {
+				headers: responseHeaders,
+				body: rawValue
+			}
+		};
+	}
 };
-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()
+const googleVertexTextEmbeddingResponseSchema = z.object({ predictions: z.array(z.object({ embeddings: z.object({
+	values: z.array(z.number()),
+	statistics: z.object({ token_count: z.number() })
+}) })) });
+const googleVertexEmbedContentResponseSchema = z.object({
+	embedding: z.object({ values: z.array(z.number()) }),
+	usageMetadata: z.object({ promptTokenCount: z.number().nullish() }).nullish()
 });
 function usesEmbedContentEndpoint(modelId) {
-  return modelId === "gemini-embedding-2" || modelId === "gemini-embedding-2-preview";
+	return modelId === "gemini-embedding-2" || modelId === "gemini-embedding-2-preview";
 }
-
-// src/google-vertex-image-model.ts
-import { GoogleLanguageModel } from "@ai-sdk/google/internal";
-import {
-  convertToBase64,
-  generateId as defaultGenerateId,
-  serializeModelOptions as serializeModelOptions2,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
-} from "@ai-sdk/provider-utils";
-var googleVertexImageModelsWithFileInputSupport = /* @__PURE__ */ new Set([
-  "gemini-2.5-flash-image",
-  "gemini-3-pro-image-preview",
-  "gemini-3.1-flash-image-preview"
+//#endregion
+//#region src/google-vertex-image-model.ts
+const googleVertexImageModelsWithFileInputSupport = /* @__PURE__ */ new Set([
+	"gemini-2.5-flash-image",
+	"gemini-3-pro-image-preview",
+	"gemini-3.1-flash-image-preview"
 ]);
-var GoogleVertexImageModel = class _GoogleVertexImageModel {
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    this.config = config;
-    this.specificationVersion = "v4";
-    this.maxImagesPerCall = 1;
-  }
-  static [WORKFLOW_SERIALIZE2](model) {
-    return serializeModelOptions2({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE2](options) {
-    return new _GoogleVertexImageModel(options.modelId, options.config);
-  }
-  get supportsFileInputs() {
-    return googleVertexImageModelsWithFileInputSupport.has(this.modelId) ? true : void 0;
-  }
-  get supportsMaskInputs() {
-    return this.supportsFileInputs === true ? false : void 0;
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async doGenerate(options) {
-    if (!this.modelId.startsWith("gemini-")) {
-      throw new Error(
-        "Google image models other than Gemini are no longer supported. Use a model ID that starts with `gemini-`."
-      );
-    }
-    const {
-      prompt,
-      size,
-      aspectRatio,
-      seed,
-      providerOptions,
-      headers,
-      abortSignal,
-      files,
-      mask
-    } = options;
-    const warnings = [];
-    if (mask != null) {
-      throw new Error(
-        "Gemini image models do not support mask-based image editing."
-      );
-    }
-    if (size != null) {
-      warnings.push({
-        type: "unsupported",
-        feature: "size",
-        details: "This model does not support the `size` option. Use `aspectRatio` instead."
-      });
-    }
-    const userContent = [];
-    if (prompt != null) {
-      userContent.push({ type: "text", text: prompt });
-    }
-    if (files != null && files.length > 0) {
-      for (const file of files) {
-        if (file.type === "url") {
-          userContent.push({
-            type: "file",
-            data: { type: "url", url: new URL(file.url) },
-            mediaType: "image/*"
-          });
-        } else {
-          userContent.push({
-            type: "file",
-            data: {
-              type: "data",
-              data: typeof file.data === "string" ? file.data : new Uint8Array(file.data)
-            },
-            mediaType: file.mediaType
-          });
-        }
-      }
-    }
-    const languageModelPrompt = [
-      { role: "user", content: userContent }
-    ];
-    const languageModel = new GoogleLanguageModel(this.modelId, {
-      provider: this.config.provider,
-      baseURL: this.config.baseURL,
-      headers: this.config.headers ?? {},
-      fetch: this.config.fetch,
-      generateId: this.config.generateId ?? defaultGenerateId,
-      supportedUrls: () => ({
-        "*": [/^https?:\/\/.*$/, /^gs:\/\/.*$/]
-      })
-    });
-    const {
-      responseModalities: _strippedResponseModalities,
-      imageConfig: userImageConfig,
-      ...userVertexOptions
-    } = providerOptions?.googleVertex ?? providerOptions?.vertex ?? {};
-    const innerVertexOptions = {
-      ...userVertexOptions,
-      responseModalities: ["IMAGE"],
-      imageConfig: aspectRatio != null || userImageConfig != null ? {
-        ...userImageConfig,
-        ...aspectRatio != null ? {
-          aspectRatio
-        } : {}
-      } : void 0
-    };
-    const result = await languageModel.doGenerate({
-      prompt: languageModelPrompt,
-      seed,
-      providerOptions: {
-        googleVertex: innerVertexOptions,
-        vertex: innerVertexOptions
-      },
-      headers,
-      abortSignal
-    });
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const images = [];
-    for (const part of result.content) {
-      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,
-      ...result.finishReason.unified === "content-filter" ? { isRetryable: false } : {},
-      warnings,
-      providerMetadata: {
-        googleVertex: geminiPayload,
-        vertex: geminiPayload
-      },
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: result.response?.headers
-      },
-      usage: result.usage ? {
-        inputTokens: result.usage.inputTokens.total,
-        outputTokens: result.usage.outputTokens.total,
-        totalTokens: (result.usage.inputTokens.total ?? 0) + (result.usage.outputTokens.total ?? 0)
-      } : void 0
-    };
-  }
+var GoogleVertexImageModel = class GoogleVertexImageModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new GoogleVertexImageModel(options.modelId, options.config);
+	}
+	get supportsFileInputs() {
+		return googleVertexImageModelsWithFileInputSupport.has(this.modelId) ? true : void 0;
+	}
+	get supportsMaskInputs() {
+		return this.supportsFileInputs === true ? false : void 0;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+		this.maxImagesPerCall = 1;
+	}
+	async doGenerate(options) {
+		if (!this.modelId.startsWith("gemini-")) throw new Error("Google image models other than Gemini are no longer supported. Use a model ID that starts with `gemini-`.");
+		const { prompt, size, aspectRatio, seed, providerOptions, headers, abortSignal, files, mask } = options;
+		const warnings = [];
+		if (mask != null) throw new Error("Gemini image models do not support mask-based image editing.");
+		if (size != null) warnings.push({
+			type: "unsupported",
+			feature: "size",
+			details: "This model does not support the `size` option. Use `aspectRatio` instead."
+		});
+		const userContent = [];
+		if (prompt != null) userContent.push({
+			type: "text",
+			text: prompt
+		});
+		if (files != null && files.length > 0) for (const file of files) if (file.type === "url") userContent.push({
+			type: "file",
+			data: {
+				type: "url",
+				url: new URL(file.url)
+			},
+			mediaType: "image/*"
+		});
+		else userContent.push({
+			type: "file",
+			data: {
+				type: "data",
+				data: typeof file.data === "string" ? file.data : new Uint8Array(file.data)
+			},
+			mediaType: file.mediaType
+		});
+		const languageModelPrompt = [{
+			role: "user",
+			content: userContent
+		}];
+		const languageModel = new GoogleLanguageModel(this.modelId, {
+			provider: this.config.provider,
+			baseURL: this.config.baseURL,
+			headers: this.config.headers ?? {},
+			fetch: this.config.fetch,
+			generateId: this.config.generateId ?? generateId,
+			supportedUrls: () => ({ "*": [/^https?:\/\/.*$/, /^gs:\/\/.*$/] })
+		});
+		const { responseModalities: _strippedResponseModalities, imageConfig: userImageConfig, ...userVertexOptions } = providerOptions?.googleVertex ?? providerOptions?.vertex ?? {};
+		const innerVertexOptions = {
+			...userVertexOptions,
+			responseModalities: ["IMAGE"],
+			imageConfig: aspectRatio != null || userImageConfig != null ? {
+				...userImageConfig,
+				...aspectRatio != null ? { aspectRatio } : {}
+			} : void 0
+		};
+		const result = await languageModel.doGenerate({
+			prompt: languageModelPrompt,
+			seed,
+			providerOptions: {
+				googleVertex: innerVertexOptions,
+				vertex: innerVertexOptions
+			},
+			headers,
+			abortSignal
+		});
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const images = [];
+		for (const part of result.content) 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,
+			...result.finishReason.unified === "content-filter" ? { isRetryable: false } : {},
+			warnings,
+			providerMetadata: {
+				googleVertex: geminiPayload,
+				vertex: geminiPayload
+			},
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: result.response?.headers
+			},
+			usage: result.usage ? {
+				inputTokens: result.usage.inputTokens.total,
+				outputTokens: result.usage.outputTokens.total,
+				totalTokens: (result.usage.inputTokens.total ?? 0) + (result.usage.outputTokens.total ?? 0)
+			} : void 0
+		};
+	}
 };
-
-// src/google-vertex-cloud-tts-speech-model.ts
-import {
-  combineHeaders as combineHeaders2,
-  convertBase64ToUint8Array,
-  createJsonResponseHandler as createJsonResponseHandler2,
-  postJsonToApi as postJsonToApi2,
-  resolve as resolve2,
-  serializeModelOptions as serializeModelOptions3,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3
-} from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod/v4";
-var DEFAULT_VOICE = "Kore";
-var DEFAULT_LANGUAGE = "en-US";
-var CHIRP3_HD_VOICE_INFIX = "Chirp3-HD";
-var CLOUD_TTS_SYNTHESIZE_URL = "https://texttospeech.googleapis.com/v1/text:synthesize";
-var GoogleVertexCloudTTSSpeechModel = class _GoogleVertexCloudTTSSpeechModel {
-  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 _GoogleVertexCloudTTSSpeechModel(options.modelId, options.config);
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async doGenerate(options) {
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const warnings = [];
-    const {
-      text,
-      voice = DEFAULT_VOICE,
-      outputFormat,
-      instructions,
-      speed,
-      language
-    } = options;
-    let voiceName;
-    let languageCode;
-    if (voice.includes(CHIRP3_HD_VOICE_INFIX)) {
-      voiceName = voice;
-      const localePrefix = voice.split(CHIRP3_HD_VOICE_INFIX)[0].replace(/-$/, "");
-      languageCode = language ?? (localePrefix || DEFAULT_LANGUAGE);
-    } else {
-      languageCode = language ?? DEFAULT_LANGUAGE;
-      voiceName = `${languageCode}-${CHIRP3_HD_VOICE_INFIX}-${voice}`;
-    }
-    if (instructions != null) {
-      warnings.push({
-        type: "unsupported",
-        feature: "instructions",
-        details: "Google Cloud Text-to-Speech Chirp 3: HD voices do not support the `instructions` option. It was ignored."
-      });
-    }
-    if (outputFormat != null && outputFormat !== "wav") {
-      warnings.push({
-        type: "unsupported",
-        feature: "outputFormat",
-        details: `Unsupported output format: ${outputFormat}. Using wav instead.`
-      });
-    }
-    const requestBody = {
-      input: { text },
-      voice: { languageCode, name: voiceName },
-      audioConfig: {
-        audioEncoding: "LINEAR16",
-        ...speed != null ? { speakingRate: speed } : {}
-      }
-    };
-    const {
-      value: response,
-      responseHeaders,
-      rawValue: rawResponse
-    } = await postJsonToApi2({
-      url: CLOUD_TTS_SYNTHESIZE_URL,
-      headers: combineHeaders2(
-        this.config.headers ? await resolve2(this.config.headers) : void 0,
-        options.headers
-      ),
-      body: requestBody,
-      failedResponseHandler: googleVertexFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler2(
-        googleVertexCloudTTSResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    const audio = response.audioContent != null ? convertBase64ToUint8Array(response.audioContent) : new Uint8Array(0);
-    return {
-      audio,
-      warnings,
-      request: {
-        body: JSON.stringify(requestBody)
-      },
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders,
-        body: rawResponse
-      },
-      providerMetadata: {
-        google: {
-          mimeType: "audio/wav"
-        }
-      }
-    };
-  }
+//#endregion
+//#region src/google-vertex-cloud-tts-speech-model.ts
+const DEFAULT_VOICE = "Kore";
+const DEFAULT_LANGUAGE = "en-US";
+const CHIRP3_HD_VOICE_INFIX = "Chirp3-HD";
+const CLOUD_TTS_SYNTHESIZE_URL = "https://texttospeech.googleapis.com/v1/text:synthesize";
+/**
+* Speech model for Chirp 3: HD voices on the Google Cloud Text-to-Speech API.
+*
+* Unlike the Gemini TTS models (which go through the Vertex
+* `generateContent` endpoint via `GoogleSpeechModel`), Chirp 3: HD voices are
+* served by the dedicated Cloud Text-to-Speech `text:synthesize` endpoint,
+* reusing the provider's Google Cloud credentials.
+*/
+var GoogleVertexCloudTTSSpeechModel = class GoogleVertexCloudTTSSpeechModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new GoogleVertexCloudTTSSpeechModel(options.modelId, options.config);
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	async doGenerate(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const warnings = [];
+		const { text, voice = DEFAULT_VOICE, outputFormat, instructions, speed, language } = options;
+		let voiceName;
+		let languageCode;
+		if (voice.includes(CHIRP3_HD_VOICE_INFIX)) {
+			voiceName = voice;
+			const localePrefix = voice.split(CHIRP3_HD_VOICE_INFIX)[0].replace(/-$/, "");
+			languageCode = language ?? (localePrefix || DEFAULT_LANGUAGE);
+		} else {
+			languageCode = language ?? DEFAULT_LANGUAGE;
+			voiceName = `${languageCode}-${CHIRP3_HD_VOICE_INFIX}-${voice}`;
+		}
+		if (instructions != null) warnings.push({
+			type: "unsupported",
+			feature: "instructions",
+			details: "Google Cloud Text-to-Speech Chirp 3: HD voices do not support the `instructions` option. It was ignored."
+		});
+		if (outputFormat != null && outputFormat !== "wav") warnings.push({
+			type: "unsupported",
+			feature: "outputFormat",
+			details: `Unsupported output format: ${outputFormat}. Using wav instead.`
+		});
+		const requestBody = {
+			input: { text },
+			voice: {
+				languageCode,
+				name: voiceName
+			},
+			audioConfig: {
+				audioEncoding: "LINEAR16",
+				...speed != null ? { speakingRate: speed } : {}
+			}
+		};
+		const { value: response, responseHeaders, rawValue: rawResponse } = await postJsonToApi({
+			url: CLOUD_TTS_SYNTHESIZE_URL,
+			headers: combineHeaders(this.config.headers ? await resolve(this.config.headers) : void 0, options.headers),
+			body: requestBody,
+			failedResponseHandler: googleVertexFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(googleVertexCloudTTSResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			audio: response.audioContent != null ? convertBase64ToUint8Array(response.audioContent) : /* @__PURE__ */ new Uint8Array(0),
+			warnings,
+			request: { body: JSON.stringify(requestBody) },
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			providerMetadata: { google: { mimeType: "audio/wav" } }
+		};
+	}
 };
-var googleVertexCloudTTSResponseSchema = z4.object({
-  audioContent: z4.string().nullish()
-});
-
-// src/google-vertex-tools.ts
-import { googleTools } from "@ai-sdk/google/internal";
-var googleVertexTools = {
-  googleSearch: googleTools.googleSearch,
-  enterpriseWebSearch: googleTools.enterpriseWebSearch,
-  googleMaps: googleTools.googleMaps,
-  urlContext: googleTools.urlContext,
-  fileSearch: googleTools.fileSearch,
-  codeExecution: googleTools.codeExecution,
-  vertexRagStore: googleTools.vertexRagStore
+const googleVertexCloudTTSResponseSchema = z.object({ audioContent: z.string().nullish() });
+//#endregion
+//#region src/google-vertex-tools.ts
+const googleVertexTools = {
+	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,
-  createJsonResponseHandler as createJsonResponseHandler3,
-  parseProviderOptions as parseProviderOptions2,
-  postJsonToApi as postJsonToApi3,
-  resolve as resolve3,
-  serializeModelOptions as serializeModelOptions4,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE4,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE4
-} from "@ai-sdk/provider-utils";
-import { z as z6 } from "zod/v4";
-
-// src/google-vertex-transcription-model-options.ts
-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()
+//#endregion
+//#region src/google-vertex-transcription-model-options.ts
+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(),
+	/**
+	* 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(),
+	/**
+	* 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()
 });
-
-// src/google-vertex-transcription-model.ts
+//#endregion
+//#region 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;
+	if (value == null) return;
+	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 {
-    return void 0;
-  }
+	if (value == null) return;
+	try {
+		const language = new Intl.Locale(value).language;
+		return language.length === 2 ? language : void 0;
+	} catch {
+		return;
+	}
 }
-var GoogleVertexTranscriptionModel = class _GoogleVertexTranscriptionModel {
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    this.config = config;
-    this.specificationVersion = "v4";
-  }
-  static [WORKFLOW_SERIALIZE4](model) {
-    return serializeModelOptions4({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE4](options) {
-    return new _GoogleVertexTranscriptionModel(options.modelId, options.config);
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async doGenerate(options) {
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const warnings = [];
-    let googleOptions;
-    for (const provider of ["googleVertex", "vertex", "google"]) {
-      googleOptions = await parseProviderOptions2({
-        provider,
-        providerOptions: options.providerOptions,
-        schema: googleVertexTranscriptionProviderOptionsSchema
-      });
-      if (googleOptions != null) {
-        break;
-      }
-    }
-    const region = googleOptions?.region ?? this.config.location;
-    const languageCodes = googleOptions?.languageCodes ?? ["auto"];
-    const content = typeof options.audio === "string" ? options.audio : convertUint8ArrayToBase64(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: googleOptions?.enableWordTimeOffsets ?? true,
-          enableAutomaticPunctuation: googleOptions?.enableAutomaticPunctuation ?? 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 = response.results ?? [];
-    const text = results.map((result) => result.alternatives?.[0]?.transcript ?? "").join(" ").trim();
-    const segments = results.flatMap(
-      (result) => result.alternatives?.[0]?.words?.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 }];
-      }) ?? []
-    );
-    const language = convertBcp47ToIso6391(results[0]?.languageCode);
-    return {
-      text,
-      segments,
-      language,
-      durationInSeconds: parseDurationSeconds(
-        response.metadata?.totalBilledDuration
-      ),
-      warnings,
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders,
-        body: rawResponse
-      }
-    };
-  }
+var GoogleVertexTranscriptionModel = class GoogleVertexTranscriptionModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new GoogleVertexTranscriptionModel(options.modelId, options.config);
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	async doGenerate(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const warnings = [];
+		let googleOptions;
+		for (const provider of [
+			"googleVertex",
+			"vertex",
+			"google"
+		]) {
+			googleOptions = await parseProviderOptions({
+				provider,
+				providerOptions: options.providerOptions,
+				schema: googleVertexTranscriptionProviderOptionsSchema
+			});
+			if (googleOptions != null) break;
+		}
+		const region = googleOptions?.region ?? this.config.location;
+		const languageCodes = googleOptions?.languageCodes ?? ["auto"];
+		const content = typeof options.audio === "string" ? options.audio : convertUint8ArrayToBase64(options.audio);
+		const requestBody = {
+			config: {
+				model: this.modelId,
+				languageCodes,
+				autoDecodingConfig: {},
+				features: {
+					enableWordTimeOffsets: googleOptions?.enableWordTimeOffsets ?? true,
+					enableAutomaticPunctuation: googleOptions?.enableAutomaticPunctuation ?? true
+				}
+			},
+			content
+		};
+		const url = `https://${region === "global" ? "speech.googleapis.com" : `${region}-speech.googleapis.com`}/v2/projects/${this.config.project}/locations/${region}/recognizers/_:recognize`;
+		const { value: response, responseHeaders, rawValue: rawResponse } = await postJsonToApi({
+			url,
+			headers: combineHeaders(this.config.headers ? await resolve(this.config.headers) : void 0, options.headers),
+			body: requestBody,
+			failedResponseHandler: googleVertexFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(googleVertexTranscriptionResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const results = response.results ?? [];
+		return {
+			text: results.map((result) => result.alternatives?.[0]?.transcript ?? "").join(" ").trim(),
+			segments: results.flatMap((result) => result.alternatives?.[0]?.words?.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
+				}];
+			}) ?? []),
+			language: convertBcp47ToIso6391(results[0]?.languageCode),
+			durationInSeconds: parseDurationSeconds(response.metadata?.totalBilledDuration),
+			warnings,
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders,
+				body: rawResponse
+			}
+		};
+	}
 };
-var googleVertexTranscriptionResponseSchema = z6.object({
-  results: z6.array(
-    z6.object({
-      alternatives: z6.array(
-        z6.object({
-          transcript: z6.string().nullish(),
-          words: z6.array(
-            z6.object({
-              word: z6.string().nullish(),
-              startOffset: z6.string().nullish(),
-              endOffset: z6.string().nullish()
-            })
-          ).nullish()
-        })
-      ).nullish(),
-      languageCode: z6.string().nullish()
-    })
-  ).nullish(),
-  metadata: z6.object({
-    totalBilledDuration: z6.string().nullish()
-  }).nullish()
+const googleVertexTranscriptionResponseSchema = z.object({
+	results: z.array(z.object({
+		alternatives: z.array(z.object({
+			transcript: z.string().nullish(),
+			words: z.array(z.object({
+				word: z.string().nullish(),
+				startOffset: z.string().nullish(),
+				endOffset: z.string().nullish()
+			})).nullish()
+		})).nullish(),
+		languageCode: z.string().nullish()
+	})).nullish(),
+	metadata: z.object({ totalBilledDuration: z.string().nullish() }).nullish()
 });
-
-// src/gemini-transcription/google-vertex-gemini-transcription-model.ts
-import {
-  InvalidArgumentError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders as combineHeaders4,
-  connectToWebSocket,
-  convertToBase64 as convertToBase642,
-  createJsonResponseHandler as createJsonResponseHandler4,
-  parseProviderOptions as parseProviderOptions3,
-  postJsonToApi as postJsonToApi4,
-  resolve as resolve4,
-  safeParseJSON,
-  serializeModelOptions as serializeModelOptions5,
-  waitForWebSocketBufferDrain,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE5,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE5
-} from "@ai-sdk/provider-utils";
-import { z as z8 } from "zod/v4";
-
-// src/gemini-transcription/google-vertex-gemini-transcription-model-options.ts
-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()
+//#endregion
+//#region src/gemini-transcription/google-vertex-gemini-transcription-model-options.ts
+/**
+* Speech recognition options for Gemini transcription models on Vertex,
+* shared by unary (`gemini-3.5-transcribe`) and live
+* (`gemini-3.5-transcribe-live`) variants. Maps onto Google's
+* `AudioTranscriptionConfig`.
+*/
+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(),
+	/**
+	* 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 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()
 });
-
-// src/gemini-transcription/google-vertex-gemini-transcription-model.ts
-var liveWebSocketPath = "google.cloud.aiplatform.v1.LlmBidiService/BidiGenerateContent";
-var defaultFinishGraceMs = 3e3;
+//#endregion
+//#region src/gemini-transcription/google-vertex-gemini-transcription-model.ts
+const liveWebSocketPath = "google.cloud.aiplatform.v1.LlmBidiService/BidiGenerateContent";
+/**
+* After the input audio has ended, finish when no terminal signal
+* (`turnComplete` / idle `interactionStatus`) arrives within this window.
+* Trailing transcripts reset the timer.
+*/
+const defaultFinishGraceMs = 3e3;
+/** Live transcription is only supported by `*-live` model variants. */
 function isLiveTranscriptionModelId(modelId) {
-  return modelId.includes("-live");
+	return modelId.includes("-live");
 }
+/** Regional Vertex hostname (mirrors the provider's base-URL host rules). */
 function vertexHost(location) {
-  if (location === "global") return "aiplatform.googleapis.com";
-  if (location === "eu" || location === "us") {
-    return `aiplatform.${location}.rep.googleapis.com`;
-  }
-  return `${location}-aiplatform.googleapis.com`;
+	if (location === "global") return "aiplatform.googleapis.com";
+	if (location === "eu" || location === "us") return `aiplatform.${location}.rep.googleapis.com`;
+	return `${location}-aiplatform.googleapis.com`;
 }
-var GoogleVertexGeminiTranscriptionModel = class _GoogleVertexGeminiTranscriptionModel {
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    this.config = config;
-    this.specificationVersion = "v4";
-  }
-  static [WORKFLOW_SERIALIZE5](model) {
-    return serializeModelOptions5({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE5](options) {
-    return new _GoogleVertexGeminiTranscriptionModel(
-      options.modelId,
-      options.config
-    );
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async parseOptions(providerOptions) {
-    for (const provider of ["googleVertex", "vertex", "google"]) {
-      const parsed = await parseProviderOptions3({
-        provider,
-        providerOptions,
-        schema: googleVertexGeminiTranscriptionModelOptions
-      });
-      if (parsed != null) return parsed;
-    }
-  }
-  async doGenerate(options) {
-    if (isLiveTranscriptionModelId(this.modelId)) {
-      throw new InvalidArgumentError({
-        argument: "modelId",
-        message: `Model '${this.modelId}' only supports streaming transcription. Use experimental_streamTranscribe, or a unary model such as 'gemini-3.5-transcribe'.`
-      });
-    }
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const warnings = [];
-    const googleOptions = await this.parseOptions(options.providerOptions);
-    const audioTranscriptionConfig = buildAudioTranscriptionConfig(googleOptions);
-    const requestBody = {
-      contents: [
-        {
-          role: "user",
-          parts: [
-            {
-              inlineData: {
-                mimeType: options.mediaType,
-                data: convertToBase642(options.audio)
-              }
-            }
-          ]
-        }
-      ],
-      ...audioTranscriptionConfig != null ? { generationConfig: { audioTranscriptionConfig } } : {}
-    };
-    const {
-      value: response,
-      responseHeaders,
-      rawValue: rawResponse
-    } = await postJsonToApi4({
-      url: `${this.config.baseURL}/models/${this.modelId}:generateContent`,
-      headers: combineHeaders4(
-        this.config.headers ? await resolve4(this.config.headers) : void 0,
-        options.headers
-      ),
-      body: requestBody,
-      failedResponseHandler: googleVertexFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler4(
-        googleVertexGeminiTranscriptionResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    const parts = response.candidates?.[0]?.content?.parts ?? [];
-    const plainText = parts.map((part) => part.text ?? "").join("");
-    const transcriptionText = parts.map((part) => part.audioTranscription?.text ?? "").join("");
-    const text = plainText !== "" ? plainText : transcriptionText;
-    let language;
-    const segments = [];
-    for (const part of parts) {
-      const transcription = part.audioTranscription;
-      if (transcription == null) continue;
-      language ??= transcription.languageCode ?? void 0;
-      for (const word of transcription.words ?? []) {
-        const startSecond = parseOffsetSeconds(word.startOffset);
-        const endSecond = parseOffsetSeconds(word.endOffset);
-        if (word.word == null || startSecond == null || endSecond == null) {
-          continue;
-        }
-        segments.push({ text: word.word, startSecond, endSecond });
-      }
-    }
-    return {
-      text,
-      segments,
-      language,
-      durationInSeconds: void 0,
-      warnings,
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders,
-        body: rawResponse
-      },
-      ...response.usageMetadata != null ? {
-        providerMetadata: {
-          google: { usageMetadata: response.usageMetadata }
-        }
-      } : {}
-    };
-  }
-  async doStream(options) {
-    if (!isLiveTranscriptionModelId(this.modelId)) {
-      throw new InvalidArgumentError({
-        argument: "modelId",
-        message: `Model '${this.modelId}' does not support streaming transcription. Use a live model such as 'gemini-3.5-transcribe-live'.`
-      });
-    }
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const warnings = [];
-    const googleOptions = await this.parseOptions(options.providerOptions);
-    validateLiveInputAudioFormat(options.inputAudioFormat);
-    const headers = combineHeaders4(
-      this.config.headers ? await resolve4(this.config.headers) : void 0,
-      options.headers
-    );
-    const { project, location } = this.config;
-    const modelResource = `projects/${project}/locations/${location}/publishers/google/models/${this.modelId}`;
-    const url = new URL(
-      `wss://${vertexHost(location)}/ws/${liveWebSocketPath}`
-    );
-    const setup = {
-      model: modelResource,
-      inputAudioTranscription: buildAudioTranscriptionConfig(googleOptions) ?? {}
-    };
-    return {
-      request: { body: setup },
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId
-      },
-      stream: createVertexLiveTranscriptionStream({
-        webSocket: this.config.webSocket,
-        url,
-        headers,
-        setup,
-        inputAudioRate: options.inputAudioFormat.rate ?? 16e3,
-        finishGraceMs: this.config._internal?.finishGraceMs ?? defaultFinishGraceMs,
-        warnings,
-        audio: options.audio,
-        abortSignal: options.abortSignal,
-        includeRawChunks: options.includeRawChunks
-      })
-    };
-  }
+/**
+* Gemini transcription on Vertex AI. Unary variants transcribe via
+* `generateContent`; live variants stream over the Vertex Live API WebSocket
+* (`LlmBidiService/BidiGenerateContent`) with OAuth Bearer authentication
+* from the provider's resolved headers.
+*/
+var GoogleVertexGeminiTranscriptionModel = class GoogleVertexGeminiTranscriptionModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new GoogleVertexGeminiTranscriptionModel(options.modelId, options.config);
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	async parseOptions(providerOptions) {
+		for (const provider of [
+			"googleVertex",
+			"vertex",
+			"google"
+		]) {
+			const parsed = await parseProviderOptions({
+				provider,
+				providerOptions,
+				schema: googleVertexGeminiTranscriptionModelOptions
+			});
+			if (parsed != null) return parsed;
+		}
+	}
+	async doGenerate(options) {
+		if (isLiveTranscriptionModelId(this.modelId)) throw new InvalidArgumentError({
+			argument: "modelId",
+			message: `Model '${this.modelId}' only supports streaming transcription. Use experimental_streamTranscribe, or a unary model such as 'gemini-3.5-transcribe'.`
+		});
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const warnings = [];
+		const audioTranscriptionConfig = buildAudioTranscriptionConfig(await this.parseOptions(options.providerOptions));
+		const requestBody = {
+			contents: [{
+				role: "user",
+				parts: [{ inlineData: {
+					mimeType: options.mediaType,
+					data: convertToBase64(options.audio)
+				} }]
+			}],
+			...audioTranscriptionConfig != null ? { generationConfig: { audioTranscriptionConfig } } : {}
+		};
+		const { value: response, responseHeaders, rawValue: rawResponse } = await postJsonToApi({
+			url: `${this.config.baseURL}/models/${this.modelId}:generateContent`,
+			headers: combineHeaders(this.config.headers ? await resolve(this.config.headers) : void 0, options.headers),
+			body: requestBody,
+			failedResponseHandler: googleVertexFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(googleVertexGeminiTranscriptionResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const parts = response.candidates?.[0]?.content?.parts ?? [];
+		const plainText = parts.map((part) => part.text ?? "").join("");
+		const transcriptionText = parts.map((part) => part.audioTranscription?.text ?? "").join("");
+		const text = plainText !== "" ? plainText : transcriptionText;
+		let language;
+		const segments = [];
+		for (const part of parts) {
+			const transcription = part.audioTranscription;
+			if (transcription == null) continue;
+			language ??= transcription.languageCode ?? void 0;
+			for (const word of transcription.words ?? []) {
+				const startSecond = parseOffsetSeconds(word.startOffset);
+				const endSecond = parseOffsetSeconds(word.endOffset);
+				if (word.word == null || startSecond == null || endSecond == null) continue;
+				segments.push({
+					text: word.word,
+					startSecond,
+					endSecond
+				});
+			}
+		}
+		return {
+			text,
+			segments,
+			language,
+			durationInSeconds: void 0,
+			warnings,
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			...response.usageMetadata != null ? { providerMetadata: { google: { usageMetadata: response.usageMetadata } } } : {}
+		};
+	}
+	async doStream(options) {
+		if (!isLiveTranscriptionModelId(this.modelId)) throw new InvalidArgumentError({
+			argument: "modelId",
+			message: `Model '${this.modelId}' does not support streaming transcription. Use a live model such as 'gemini-3.5-transcribe-live'.`
+		});
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const warnings = [];
+		const googleOptions = await this.parseOptions(options.providerOptions);
+		validateLiveInputAudioFormat(options.inputAudioFormat);
+		const headers = combineHeaders(this.config.headers ? await resolve(this.config.headers) : void 0, options.headers);
+		const { project, location } = this.config;
+		const modelResource = `projects/${project}/locations/${location}/publishers/google/models/${this.modelId}`;
+		const url = new URL(`wss://${vertexHost(location)}/ws/${liveWebSocketPath}`);
+		const setup = {
+			model: modelResource,
+			inputAudioTranscription: buildAudioTranscriptionConfig(googleOptions) ?? {}
+		};
+		return {
+			request: { body: setup },
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId
+			},
+			stream: createVertexLiveTranscriptionStream({
+				webSocket: this.config.webSocket,
+				url,
+				headers,
+				setup,
+				inputAudioRate: options.inputAudioFormat.rate ?? 16e3,
+				finishGraceMs: this.config._internal?.finishGraceMs ?? defaultFinishGraceMs,
+				warnings,
+				audio: options.audio,
+				abortSignal: options.abortSignal,
+				includeRawChunks: options.includeRawChunks
+			})
+		};
+	}
 };
-function createVertexLiveTranscriptionStream({
-  webSocket,
-  url,
-  headers,
-  setup,
-  inputAudioRate,
-  finishGraceMs,
-  warnings,
-  audio,
-  abortSignal,
-  includeRawChunks
-}) {
-  let finished = false;
-  let cleanup = () => {
-  };
-  return new ReadableStream({
-    start: (controller) => {
-      let audioReader;
-      let connection;
-      let resolveSetupComplete;
-      const setupComplete = new Promise((resolvePromise) => {
-        resolveSetupComplete = resolvePromise;
-      });
-      let segmentCounter = 0;
-      let segmentBuffer = "";
-      let fullText = "";
-      let latestInterim = "";
-      let language;
-      let audioEnded = false;
-      let usageMetadata;
-      let finishTimer;
-      const segmentId = () => `google-segment-${segmentCounter}`;
-      const cancelPendingFinish = () => {
-        if (finishTimer != null) {
-          clearTimeout(finishTimer);
-          finishTimer = void 0;
-        }
-      };
-      const schedulePendingFinish = () => {
-        if (finished || !audioEnded) return;
-        cancelPendingFinish();
-        finishTimer = setTimeout(() => {
-          finishTimer = void 0;
-          finish();
-        }, finishGraceMs);
-      };
-      cleanup = (closeCode) => {
-        cancelPendingFinish();
-        if (audioReader != null) {
-          void audioReader.cancel().catch(() => {
-          });
-        } else {
-          void audio.cancel().catch(() => {
-          });
-        }
-        connection?.close(closeCode);
-      };
-      const finishWithError = (error) => {
-        if (finished) return;
-        finished = true;
-        cleanup();
-        controller.error(error);
-      };
-      const completeSegment = () => {
-        if (segmentBuffer === "") {
-          if (latestInterim === "") return;
-          segmentBuffer = latestInterim;
-        }
-        latestInterim = "";
-        controller.enqueue({
-          type: "transcript-final",
-          id: segmentId(),
-          text: segmentBuffer
-        });
-        fullText += fullText === "" ? segmentBuffer : ` ${segmentBuffer}`;
-        segmentBuffer = "";
-        segmentCounter++;
-      };
-      const finish = () => {
-        if (finished) return;
-        completeSegment();
-        finished = true;
-        controller.enqueue({
-          type: "finish",
-          text: fullText,
-          segments: [],
-          language,
-          durationInSeconds: void 0,
-          ...usageMetadata != null ? { providerMetadata: { google: { usageMetadata } } } : {}
-        });
-        controller.close();
-        cleanup(1e3);
-      };
-      const sendAudio = async (socket) => {
-        audioReader = audio.getReader();
-        try {
-          while (true) {
-            const { done, value } = await audioReader.read();
-            if (done || finished) break;
-            socket.send(
-              JSON.stringify({
-                realtimeInput: {
-                  audio: {
-                    data: convertToBase642(value),
-                    mimeType: `audio/pcm;rate=${inputAudioRate}`
-                  }
-                }
-              })
-            );
-            await waitForWebSocketBufferDrain(socket);
-          }
-        } finally {
-          audioReader.releaseLock();
-          audioReader = void 0;
-        }
-        if (!finished) {
-          socket.send(
-            JSON.stringify({ realtimeInput: { audioStreamEnd: true } })
-          );
-          audioEnded = true;
-          schedulePendingFinish();
-        }
-      };
-      connection = connectToWebSocket({
-        url,
-        headers,
-        webSocket,
-        abortSignal,
-        onAbort: finishWithError,
-        onProcessingError: finishWithError,
-        onOpen: (socket) => {
-          controller.enqueue({ type: "stream-start", warnings });
-          socket.send(JSON.stringify({ setup }));
-          void setupComplete.then(() => finished ? void 0 : sendAudio(socket)).catch(finishWithError);
-        },
-        onMessageText: async (text) => {
-          if (finished) return;
-          const parsed = await safeParseJSON({ text });
-          if (!parsed.success) return;
-          const message = parsed.value;
-          if (includeRawChunks) {
-            controller.enqueue({ type: "raw", rawValue: message });
-          }
-          if (message.setupComplete != null) {
-            resolveSetupComplete();
-          }
-          if (message.usageMetadata != null) {
-            usageMetadata = message.usageMetadata;
-          }
-          if (message.error != null) {
-            finishWithError(
-              new Error(message.error.message ?? "Vertex Live API error")
-            );
-            return;
-          }
-          const serverContent = message.serverContent;
-          const interim = serverContent?.interimInputTranscription;
-          if (interim?.text) {
-            schedulePendingFinish();
-            latestInterim = interim.text;
-            controller.enqueue({
-              type: "transcript-partial",
-              id: segmentId(),
-              text: interim.text
-            });
-          }
-          const transcription = serverContent?.inputTranscription ?? message.inputTranscription;
-          if (transcription != null) {
-            if (transcription.languageCode != null) {
-              language = transcription.languageCode;
-            }
-            if (transcription.text) {
-              schedulePendingFinish();
-              latestInterim = "";
-              segmentBuffer += transcription.text;
-              controller.enqueue({
-                type: "transcript-delta",
-                id: segmentId(),
-                delta: transcription.text
-              });
-            }
-            if (transcription.finished === true) {
-              completeSegment();
-            }
-          }
-          if (serverContent?.turnComplete) {
-            completeSegment();
-          }
-          const interactionStatus = serverContent?.interactionStatus;
-          if (audioEnded && (interactionStatus === "IDLE" || interactionStatus === "REQUIRES_ACTION" || serverContent?.turnComplete === true && interactionStatus == null)) {
-            finish();
-          }
-        },
-        onSocketError: () => {
-          finishWithError(
-            new Error(
-              "Vertex Live transcription error." + (webSocket == null ? " Note: the native WebSocket implementation cannot send the Authorization header required by Vertex. Pass a header-capable WebSocket implementation (e.g. the 'ws' package) via createVertex({ webSocket })." : "")
-            )
-          );
-        },
-        onClose: ({ code, reason }) => {
-          if (finished) return;
-          if (audioEnded) {
-            finish();
-            return;
-          }
-          finishWithError(
-            new Error(
-              `Vertex Live transcription WebSocket closed unexpectedly before finishing (code ${code ?? "unknown"}${reason ? `, reason: ${reason}` : ""}).`
-            )
-          );
-        }
-      });
-    },
-    cancel: () => {
-      if (finished) return;
-      finished = true;
-      cleanup();
-    }
-  });
+function createVertexLiveTranscriptionStream({ webSocket, url, headers, setup, inputAudioRate, finishGraceMs, warnings, audio, abortSignal, includeRawChunks }) {
+	let finished = false;
+	let cleanup = () => {};
+	return new ReadableStream({
+		start: (controller) => {
+			let audioReader;
+			let connection;
+			let resolveSetupComplete;
+			const setupComplete = new Promise((resolvePromise) => {
+				resolveSetupComplete = resolvePromise;
+			});
+			let segmentCounter = 0;
+			let segmentBuffer = "";
+			let fullText = "";
+			let latestInterim = "";
+			let language;
+			let audioEnded = false;
+			let usageMetadata;
+			let finishTimer;
+			const segmentId = () => `google-segment-${segmentCounter}`;
+			const cancelPendingFinish = () => {
+				if (finishTimer != null) {
+					clearTimeout(finishTimer);
+					finishTimer = void 0;
+				}
+			};
+			const schedulePendingFinish = () => {
+				if (finished || !audioEnded) return;
+				cancelPendingFinish();
+				finishTimer = setTimeout(() => {
+					finishTimer = void 0;
+					finish();
+				}, finishGraceMs);
+			};
+			cleanup = (closeCode) => {
+				cancelPendingFinish();
+				if (audioReader != null) audioReader.cancel().catch(() => {});
+				else audio.cancel().catch(() => {});
+				connection?.close(closeCode);
+			};
+			const finishWithError = (error) => {
+				if (finished) return;
+				finished = true;
+				cleanup();
+				controller.error(error);
+			};
+			const completeSegment = () => {
+				if (segmentBuffer === "") {
+					if (latestInterim === "") return;
+					segmentBuffer = latestInterim;
+				}
+				latestInterim = "";
+				controller.enqueue({
+					type: "transcript-final",
+					id: segmentId(),
+					text: segmentBuffer
+				});
+				fullText += fullText === "" ? segmentBuffer : ` ${segmentBuffer}`;
+				segmentBuffer = "";
+				segmentCounter++;
+			};
+			const finish = () => {
+				if (finished) return;
+				completeSegment();
+				finished = true;
+				controller.enqueue({
+					type: "finish",
+					text: fullText,
+					segments: [],
+					language,
+					durationInSeconds: void 0,
+					...usageMetadata != null ? { providerMetadata: { google: { usageMetadata } } } : {}
+				});
+				controller.close();
+				cleanup(1e3);
+			};
+			const sendAudio = async (socket) => {
+				audioReader = audio.getReader();
+				try {
+					while (true) {
+						const { done, value } = await audioReader.read();
+						if (done || finished) break;
+						socket.send(JSON.stringify({ realtimeInput: { audio: {
+							data: convertToBase64(value),
+							mimeType: `audio/pcm;rate=${inputAudioRate}`
+						} } }));
+						await waitForWebSocketBufferDrain(socket);
+					}
+				} finally {
+					audioReader.releaseLock();
+					audioReader = void 0;
+				}
+				if (!finished) {
+					socket.send(JSON.stringify({ realtimeInput: { audioStreamEnd: true } }));
+					audioEnded = true;
+					schedulePendingFinish();
+				}
+			};
+			connection = connectToWebSocket({
+				url,
+				headers,
+				webSocket,
+				abortSignal,
+				onAbort: finishWithError,
+				onProcessingError: finishWithError,
+				onOpen: (socket) => {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+					socket.send(JSON.stringify({ setup }));
+					setupComplete.then(() => finished ? void 0 : sendAudio(socket)).catch(finishWithError);
+				},
+				onMessageText: async (text) => {
+					if (finished) return;
+					const parsed = await safeParseJSON({ text });
+					if (!parsed.success) return;
+					const message = parsed.value;
+					if (includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: message
+					});
+					if (message.setupComplete != null) resolveSetupComplete();
+					if (message.usageMetadata != null) usageMetadata = message.usageMetadata;
+					if (message.error != null) {
+						finishWithError(new Error(message.error.message ?? "Vertex Live API error"));
+						return;
+					}
+					const serverContent = message.serverContent;
+					const interim = serverContent?.interimInputTranscription;
+					if (interim?.text) {
+						schedulePendingFinish();
+						latestInterim = interim.text;
+						controller.enqueue({
+							type: "transcript-partial",
+							id: segmentId(),
+							text: interim.text
+						});
+					}
+					const transcription = serverContent?.inputTranscription ?? message.inputTranscription;
+					if (transcription != null) {
+						if (transcription.languageCode != null) language = transcription.languageCode;
+						if (transcription.text) {
+							schedulePendingFinish();
+							latestInterim = "";
+							segmentBuffer += transcription.text;
+							controller.enqueue({
+								type: "transcript-delta",
+								id: segmentId(),
+								delta: transcription.text
+							});
+						}
+						if (transcription.finished === true) completeSegment();
+					}
+					if (serverContent?.turnComplete) completeSegment();
+					const interactionStatus = serverContent?.interactionStatus;
+					if (audioEnded && (interactionStatus === "IDLE" || interactionStatus === "REQUIRES_ACTION" || serverContent?.turnComplete === true && interactionStatus == null)) finish();
+				},
+				onSocketError: () => {
+					finishWithError(/* @__PURE__ */ new Error("Vertex Live transcription error." + (webSocket == null ? " Note: the native WebSocket implementation cannot send the Authorization header required by Vertex. Pass a header-capable WebSocket implementation (e.g. the 'ws' package) via createVertex({ webSocket })." : "")));
+				},
+				onClose: ({ code, reason }) => {
+					if (finished) return;
+					if (audioEnded) {
+						finish();
+						return;
+					}
+					finishWithError(/* @__PURE__ */ new Error(`Vertex Live transcription WebSocket closed unexpectedly before finishing (code ${code ?? "unknown"}${reason ? `, reason: ${reason}` : ""}).`));
+				}
+			});
+		},
+		cancel: () => {
+			if (finished) return;
+			finished = true;
+			cleanup();
+		}
+	});
 }
+/**
+* Builds Google's `AudioTranscriptionConfig` from provider options; returns
+* undefined when no options are set.
+*/
 function buildAudioTranscriptionConfig(options) {
-  if (options == null) return void 0;
-  const config = {};
-  if (options.languageCodes != null) {
-    config.languageCodes = options.languageCodes;
-  }
-  if (options.customVocabulary != null) {
-    config.customVocabulary = options.customVocabulary;
-  }
-  if (options.wordTimestamp != null) {
-    config.wordTimestamp = options.wordTimestamp;
-  }
-  if (options.diarization != null) {
-    config.diarization = options.diarization;
-  }
-  if (options.mode != null) {
-    config.mode = options.mode;
-  }
-  return Object.keys(config).length > 0 ? config : void 0;
+	if (options == null) return void 0;
+	const config = {};
+	if (options.languageCodes != null) config.languageCodes = options.languageCodes;
+	if (options.customVocabulary != null) config.customVocabulary = options.customVocabulary;
+	if (options.wordTimestamp != null) config.wordTimestamp = options.wordTimestamp;
+	if (options.diarization != null) config.diarization = options.diarization;
+	if (options.mode != null) config.mode = options.mode;
+	return Object.keys(config).length > 0 ? config : void 0;
 }
 function validateLiveInputAudioFormat(inputAudioFormat) {
-  if (inputAudioFormat.type !== "audio/pcm" || inputAudioFormat.rate != null && inputAudioFormat.rate !== 16e3) {
-    throw new InvalidArgumentError({
-      argument: "inputAudioFormat",
-      message: "The Gemini Live transcription API only supports 16kHz 16-bit PCM input audio."
-    });
-  }
+	if (inputAudioFormat.type !== "audio/pcm" || inputAudioFormat.rate != null && inputAudioFormat.rate !== 16e3) throw new InvalidArgumentError({
+		argument: "inputAudioFormat",
+		message: "The Gemini Live transcription API only supports 16kHz 16-bit PCM input audio."
+	});
 }
+/** Parses a Google duration offset such as `"1s"` or `"9.400s"` to seconds. */
 function parseOffsetSeconds(offset) {
-  if (offset == null) return void 0;
-  const parsed = Number.parseFloat(offset);
-  return Number.isFinite(parsed) ? parsed : void 0;
+	if (offset == null) return void 0;
+	const parsed = Number.parseFloat(offset);
+	return Number.isFinite(parsed) ? parsed : void 0;
 }
-var googleVertexGeminiTranscriptionWordSchema = z8.object({
-  word: z8.string().nullish(),
-  startOffset: z8.string().nullish(),
-  endOffset: z8.string().nullish()
+const googleVertexGeminiTranscriptionWordSchema = z.object({
+	word: z.string().nullish(),
+	startOffset: z.string().nullish(),
+	endOffset: z.string().nullish()
 });
-var googleVertexGeminiTranscriptionResponseSchema = z8.object({
-  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()
+const googleVertexGeminiTranscriptionResponseSchema = z.object({
+	candidates: z.array(z.object({ content: z.object({ parts: z.array(z.object({
+		text: z.string().nullish(),
+		audioTranscription: z.object({
+			text: z.string().nullish(),
+			languageCode: z.string().nullish(),
+			speakerLabel: z.string().nullish(),
+			words: z.array(googleVertexGeminiTranscriptionWordSchema).nullish()
+		}).nullish()
+	})).nullish() }).nullish() })).nullish(),
+	usageMetadata: z.record(z.string(), z.unknown()).nullish()
 });
-
-// src/google-vertex-video-model.ts
-import {
-  AISDKError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders as combineHeaders5,
-  convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
-  createJsonResponseHandler as createJsonResponseHandler5,
-  parseProviderOptions as parseProviderOptions4,
-  postJsonToApi as postJsonToApi5,
-  resolve as resolve5
-} from "@ai-sdk/provider-utils";
-import { z as z10 } from "zod/v4";
-
-// src/google-vertex-video-model-options.ts
-import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
-import { z as z9 } from "zod/v4";
-var googleVertexVideoModelOptionsSchema = lazySchema(
-  () => zodSchema(
-    z9.looseObject({
-      pollIntervalMs: z9.number().positive().nullish(),
-      pollTimeoutMs: z9.number().positive().nullish(),
-      personGeneration: z9.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-      negativePrompt: z9.string().nullish(),
-      generateAudio: z9.boolean().nullish(),
-      gcsOutputDirectory: z9.string().nullish(),
-      referenceImages: z9.array(
-        z9.object({
-          bytesBase64Encoded: z9.string().nullish(),
-          gcsUri: z9.string().nullish()
-        })
-      ).nullish()
-    })
-  )
-);
-
-// src/google-vertex-video-model.ts
+//#endregion
+//#region src/google-vertex-video-model-options.ts
+const googleVertexVideoModelOptionsSchema = lazySchema(() => zodSchema(z.looseObject({
+	pollIntervalMs: z.number().positive().nullish(),
+	pollTimeoutMs: z.number().positive().nullish(),
+	personGeneration: z.enum([
+		"dont_allow",
+		"allow_adult",
+		"allow_all"
+	]).nullish(),
+	negativePrompt: z.string().nullish(),
+	generateAudio: z.boolean().nullish(),
+	gcsOutputDirectory: z.string().nullish(),
+	referenceImages: z.array(z.object({
+		bytesBase64Encoded: z.string().nullish(),
+		gcsUri: z.string().nullish()
+	})).nullish()
+})));
+//#endregion
+//#region src/google-vertex-video-model.ts
 function getFirstFrameImage(options) {
-  return options.frameImages?.find((frame) => frame.frameType === "first_frame")?.image;
+	return options.frameImages?.find((frame) => frame.frameType === "first_frame")?.image;
 }
 function resolveStartImage(options) {
-  return getFirstFrameImage(options) ?? options.image;
+	return getFirstFrameImage(options) ?? options.image;
 }
 function getLastFrameImage(options) {
-  return options.frameImages?.find((frame) => frame.frameType === "last_frame")?.image;
+	return options.frameImages?.find((frame) => frame.frameType === "last_frame")?.image;
 }
 function getInputReferences(options) {
-  if (options.frameImages != null && options.frameImages.length > 0) {
-    return void 0;
-  }
-  return options.inputReferences != null && options.inputReferences.length > 0 ? options.inputReferences : void 0;
+	if (options.frameImages != null && options.frameImages.length > 0) return;
+	return options.inputReferences != null && options.inputReferences.length > 0 ? options.inputReferences : void 0;
 }
 function convertFileToVertexImage(file, warnings) {
-  if (file.type === "url") {
-    if (file.url.startsWith("gs://")) {
-      return {
-        gcsUri: file.url,
-        mimeType: "image/png"
-      };
-    }
-    warnings.push({
-      type: "unsupported",
-      feature: "URL-based image input",
-      details: "Vertex AI video models require base64-encoded images or GCS URIs. URL will be ignored."
-    });
-    return void 0;
-  }
-  const base64Data = typeof file.data === "string" ? file.data : convertUint8ArrayToBase642(file.data);
-  return {
-    bytesBase64Encoded: base64Data,
-    mimeType: file.mediaType || "image/png"
-  };
+	if (file.type === "url") {
+		if (file.url.startsWith("gs://")) return {
+			gcsUri: file.url,
+			mimeType: "image/png"
+		};
+		warnings.push({
+			type: "unsupported",
+			feature: "URL-based image input",
+			details: "Vertex AI video models require base64-encoded images or GCS URIs. URL will be ignored."
+		});
+		return;
+	}
+	return {
+		bytesBase64Encoded: typeof file.data === "string" ? file.data : convertUint8ArrayToBase64(file.data),
+		mimeType: file.mediaType || "image/png"
+	};
 }
 function convertInputReferenceImage(file, warnings) {
-  const image = convertFileToVertexImage(file, warnings);
-  return image != null ? { image, referenceType: "asset" } : void 0;
+	const image = convertFileToVertexImage(file, warnings);
+	return image != null ? {
+		image,
+		referenceType: "asset"
+	} : void 0;
 }
 var GoogleVertexVideoModel = class {
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    this.config = config;
-    this.specificationVersion = "v4";
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  get maxVideosPerCall() {
-    return 4;
-  }
-  async buildRequest(options) {
-    const warnings = [];
-    const googleVertexOptions = await parseProviderOptions4({
-      provider: "googleVertex",
-      providerOptions: options.providerOptions,
-      schema: googleVertexVideoModelOptionsSchema
-    }) ?? await parseProviderOptions4({
-      provider: "vertex",
-      providerOptions: options.providerOptions,
-      schema: googleVertexVideoModelOptionsSchema
-    });
-    const instances = [{}];
-    const instance = instances[0];
-    if (options.prompt != null) {
-      instance.prompt = options.prompt;
-    }
-    const startImage = resolveStartImage(options);
-    if (startImage != null) {
-      const image = convertFileToVertexImage(startImage, warnings);
-      if (image != null) {
-        instance.image = image;
-      }
-    }
-    const lastFrameImage = getLastFrameImage(options);
-    if (lastFrameImage != null) {
-      const lastFrame = convertFileToVertexImage(lastFrameImage, warnings);
-      if (lastFrame != null) {
-        instance.lastFrame = lastFrame;
-      }
-    }
-    const inputReferences = getInputReferences(options);
-    if (inputReferences != null) {
-      instance.referenceImages = inputReferences.flatMap((reference) => {
-        const converted = convertInputReferenceImage(reference, warnings);
-        return converted != null ? [converted] : [];
-      });
-    } else if (googleVertexOptions?.referenceImages != null) {
-      instance.referenceImages = googleVertexOptions.referenceImages;
-    }
-    const parameters = {
-      sampleCount: options.n
-    };
-    if (options.aspectRatio) {
-      parameters.aspectRatio = options.aspectRatio;
-    }
-    if (options.resolution) {
-      const resolutionMap = {
-        "1280x720": "720p",
-        "1920x1080": "1080p",
-        "3840x2160": "4k"
-      };
-      parameters.resolution = resolutionMap[options.resolution] || options.resolution;
-    }
-    if (options.duration) {
-      parameters.durationSeconds = options.duration;
-    }
-    if (options.seed) {
-      parameters.seed = options.seed;
-    }
-    const generateAudio = options.generateAudio ?? 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.gcsOutputDirectory !== void 0 && opts.gcsOutputDirectory !== null) {
-        parameters.gcsOutputDirectory = opts.gcsOutputDirectory;
-      }
-      for (const [key, value] of Object.entries(opts)) {
-        if (![
-          "pollIntervalMs",
-          "pollTimeoutMs",
-          "personGeneration",
-          "negativePrompt",
-          "generateAudio",
-          "gcsOutputDirectory",
-          "referenceImages"
-        ].includes(key)) {
-          parameters[key] = value;
-        }
-      }
-    }
-    return { instances, parameters, warnings, googleVertexOptions };
-  }
-  buildCompletedResult({
-    finalOperation,
-    responseHeaders,
-    warnings,
-    currentDate
-  }) {
-    const response = finalOperation.response;
-    if (!response?.videos || response.videos.length === 0) {
-      throw new AISDKError({
-        name: "VERTEX_VIDEO_GENERATION_ERROR",
-        message: `No videos in response. Response: ${JSON.stringify(finalOperation)}`
-      });
-    }
-    const videos = [];
-    const videoMetadata = [];
-    for (const video of response.videos) {
-      if (video.bytesBase64Encoded) {
-        videos.push({
-          type: "base64",
-          data: video.bytesBase64Encoded,
-          mediaType: video.mimeType || "video/mp4"
-        });
-        videoMetadata.push({
-          mimeType: video.mimeType
-        });
-      } else if (video.gcsUri) {
-        videos.push({
-          type: "url",
-          url: video.gcsUri,
-          mediaType: video.mimeType || "video/mp4"
-        });
-        videoMetadata.push({
-          gcsUri: video.gcsUri,
-          mimeType: video.mimeType
-        });
-      }
-    }
-    if (videos.length === 0) {
-      throw new AISDKError({
-        name: "VERTEX_VIDEO_GENERATION_ERROR",
-        message: "No valid videos in response"
-      });
-    }
-    return {
-      status: "completed",
-      videos,
-      warnings,
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders
-      },
-      providerMetadata: /* @__PURE__ */ (() => {
-        const payload = { videos: videoMetadata };
-        return {
-          googleVertex: payload,
-          // Legacy keys preserved for backward compatibility.
-          "google-vertex": payload,
-          vertex: payload
-        };
-      })()
-    };
-  }
-  async doStart(options) {
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const { instances, parameters, warnings } = await this.buildRequest(options);
-    const { value: operation, responseHeaders } = await postJsonToApi5({
-      url: `${this.config.baseURL}/models/${this.modelId}:predictLongRunning`,
-      headers: combineHeaders5(
-        await resolve5(this.config.headers),
-        options.headers
-      ),
-      body: {
-        instances,
-        parameters
-      },
-      successfulResponseHandler: createJsonResponseHandler5(
-        googleVertexOperationSchema
-      ),
-      failedResponseHandler: googleVertexFailedResponseHandler,
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    const operationName = operation.name;
-    if (!operationName) {
-      throw new AISDKError({
-        name: "VERTEX_VIDEO_GENERATION_ERROR",
-        message: "No operation name returned from API"
-      });
-    }
-    return {
-      operation: { operationName },
-      warnings,
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders
-      }
-    };
-  }
-  async doStatus(options) {
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const { operationName } = options.operation;
-    const { value: statusOperation, responseHeaders } = await postJsonToApi5({
-      url: `${this.config.baseURL}/models/${this.modelId}:fetchPredictOperation`,
-      headers: combineHeaders5(
-        await resolve5(this.config.headers),
-        options.headers
-      ),
-      body: {
-        operationName
-      },
-      successfulResponseHandler: createJsonResponseHandler5(
-        googleVertexOperationSchema
-      ),
-      failedResponseHandler: googleVertexFailedResponseHandler,
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    if (!statusOperation.done) {
-      return {
-        status: "pending",
-        response: {
-          timestamp: currentDate,
-          modelId: this.modelId,
-          headers: responseHeaders
-        }
-      };
-    }
-    if (statusOperation.error) {
-      return {
-        status: "error",
-        error: `Video generation failed: ${statusOperation.error.message}`,
-        response: {
-          timestamp: currentDate,
-          modelId: this.modelId,
-          headers: responseHeaders
-        }
-      };
-    }
-    return this.buildCompletedResult({
-      finalOperation: statusOperation,
-      responseHeaders,
-      warnings: [],
-      currentDate
-    });
-  }
+	get provider() {
+		return this.config.provider;
+	}
+	get maxVideosPerCall() {
+		return 4;
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	async buildRequest(options) {
+		const warnings = [];
+		const googleVertexOptions = await parseProviderOptions({
+			provider: "googleVertex",
+			providerOptions: options.providerOptions,
+			schema: googleVertexVideoModelOptionsSchema
+		}) ?? await parseProviderOptions({
+			provider: "vertex",
+			providerOptions: options.providerOptions,
+			schema: googleVertexVideoModelOptionsSchema
+		});
+		const instances = [{}];
+		const instance = instances[0];
+		if (options.prompt != null) instance.prompt = options.prompt;
+		const startImage = resolveStartImage(options);
+		if (startImage != null) {
+			const image = convertFileToVertexImage(startImage, warnings);
+			if (image != null) instance.image = image;
+		}
+		const lastFrameImage = getLastFrameImage(options);
+		if (lastFrameImage != null) {
+			const lastFrame = convertFileToVertexImage(lastFrameImage, warnings);
+			if (lastFrame != null) instance.lastFrame = lastFrame;
+		}
+		const inputReferences = getInputReferences(options);
+		if (inputReferences != null) instance.referenceImages = inputReferences.flatMap((reference) => {
+			const converted = convertInputReferenceImage(reference, warnings);
+			return converted != null ? [converted] : [];
+		});
+		else if (googleVertexOptions?.referenceImages != null) instance.referenceImages = googleVertexOptions.referenceImages;
+		const parameters = { sampleCount: options.n };
+		if (options.aspectRatio) parameters.aspectRatio = options.aspectRatio;
+		if (options.resolution) parameters.resolution = {
+			"1280x720": "720p",
+			"1920x1080": "1080p",
+			"3840x2160": "4k"
+		}[options.resolution] || options.resolution;
+		if (options.duration) parameters.durationSeconds = options.duration;
+		if (options.seed) parameters.seed = options.seed;
+		const generateAudio = options.generateAudio ?? 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.gcsOutputDirectory !== void 0 && opts.gcsOutputDirectory !== null) parameters.gcsOutputDirectory = opts.gcsOutputDirectory;
+			for (const [key, value] of Object.entries(opts)) if (![
+				"pollIntervalMs",
+				"pollTimeoutMs",
+				"personGeneration",
+				"negativePrompt",
+				"generateAudio",
+				"gcsOutputDirectory",
+				"referenceImages"
+			].includes(key)) parameters[key] = value;
+		}
+		return {
+			instances,
+			parameters,
+			warnings,
+			googleVertexOptions
+		};
+	}
+	buildCompletedResult({ finalOperation, responseHeaders, warnings, currentDate }) {
+		const response = finalOperation.response;
+		if (!response?.videos || response.videos.length === 0) throw new AISDKError({
+			name: "VERTEX_VIDEO_GENERATION_ERROR",
+			message: `No videos in response. Response: ${JSON.stringify(finalOperation)}`
+		});
+		const videos = [];
+		const videoMetadata = [];
+		for (const video of response.videos) if (video.bytesBase64Encoded) {
+			videos.push({
+				type: "base64",
+				data: video.bytesBase64Encoded,
+				mediaType: video.mimeType || "video/mp4"
+			});
+			videoMetadata.push({ mimeType: video.mimeType });
+		} else if (video.gcsUri) {
+			videos.push({
+				type: "url",
+				url: video.gcsUri,
+				mediaType: video.mimeType || "video/mp4"
+			});
+			videoMetadata.push({
+				gcsUri: video.gcsUri,
+				mimeType: video.mimeType
+			});
+		}
+		if (videos.length === 0) throw new AISDKError({
+			name: "VERTEX_VIDEO_GENERATION_ERROR",
+			message: "No valid videos in response"
+		});
+		return {
+			status: "completed",
+			videos,
+			warnings,
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders
+			},
+			providerMetadata: (() => {
+				const payload = { videos: videoMetadata };
+				return {
+					googleVertex: payload,
+					"google-vertex": payload,
+					vertex: payload
+				};
+			})()
+		};
+	}
+	async doStart(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const { instances, parameters, warnings } = await this.buildRequest(options);
+		const { value: operation, responseHeaders } = await postJsonToApi({
+			url: `${this.config.baseURL}/models/${this.modelId}:predictLongRunning`,
+			headers: combineHeaders(await resolve(this.config.headers), options.headers),
+			body: {
+				instances,
+				parameters
+			},
+			successfulResponseHandler: createJsonResponseHandler(googleVertexOperationSchema),
+			failedResponseHandler: googleVertexFailedResponseHandler,
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const operationName = operation.name;
+		if (!operationName) throw new AISDKError({
+			name: "VERTEX_VIDEO_GENERATION_ERROR",
+			message: "No operation name returned from API"
+		});
+		return {
+			operation: { operationName },
+			warnings,
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders
+			}
+		};
+	}
+	async doStatus(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const { operationName } = options.operation;
+		const { value: statusOperation, responseHeaders } = await postJsonToApi({
+			url: `${this.config.baseURL}/models/${this.modelId}:fetchPredictOperation`,
+			headers: combineHeaders(await resolve(this.config.headers), options.headers),
+			body: { operationName },
+			successfulResponseHandler: createJsonResponseHandler(googleVertexOperationSchema),
+			failedResponseHandler: googleVertexFailedResponseHandler,
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		if (!statusOperation.done) return {
+			status: "pending",
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders
+			}
+		};
+		if (statusOperation.error) return {
+			status: "error",
+			error: `Video generation failed: ${statusOperation.error.message}`,
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders
+			}
+		};
+		return this.buildCompletedResult({
+			finalOperation: statusOperation,
+			responseHeaders,
+			warnings: [],
+			currentDate
+		});
+	}
 };
-var googleVertexOperationSchema = z10.object({
-  name: z10.string().nullish(),
-  done: z10.boolean().nullish(),
-  error: z10.object({
-    code: z10.number().nullish(),
-    message: z10.string(),
-    status: z10.string().nullish()
-  }).nullish(),
-  response: z10.object({
-    videos: z10.array(
-      z10.object({
-        bytesBase64Encoded: z10.string().nullish(),
-        gcsUri: z10.string().nullish(),
-        mimeType: z10.string().nullish()
-      })
-    ).nullish(),
-    raiMediaFilteredCount: z10.number().nullish()
-  }).nullish()
+const googleVertexOperationSchema = z.object({
+	name: z.string().nullish(),
+	done: z.boolean().nullish(),
+	error: z.object({
+		code: z.number().nullish(),
+		message: z.string(),
+		status: z.string().nullish()
+	}).nullish(),
+	response: z.object({
+		videos: z.array(z.object({
+			bytesBase64Encoded: z.string().nullish(),
+			gcsUri: z.string().nullish(),
+			mimeType: z.string().nullish()
+		})).nullish(),
+		raiMediaFilteredCount: z.number().nullish()
+	}).nullish()
 });
-
-// src/google-vertex-provider-base.ts
-var EXPRESS_MODE_BASE_URL = "https://aiplatform.googleapis.com/v1/publishers/google";
-var ENDPOINT_MODEL_PREFIX = "endpoints/";
+//#endregion
+//#region src/google-vertex-provider-base.ts
+const EXPRESS_MODE_BASE_URL = "https://aiplatform.googleapis.com/v1/publishers/google";
+const ENDPOINT_MODEL_PREFIX = "endpoints/";
 function isEndpointModelId(modelId) {
-  return modelId.startsWith(ENDPOINT_MODEL_PREFIX);
+	return modelId.startsWith(ENDPOINT_MODEL_PREFIX);
 }
 function createExpressModeFetch(apiKey, customFetch) {
-  return async (url, init) => {
-    const modifiedInit = {
-      ...init,
-      headers: {
-        ...init?.headers ? normalizeHeaders(init.headers) : {},
-        "x-goog-api-key": apiKey
-      }
-    };
-    return (customFetch ?? fetch)(url.toString(), modifiedInit);
-  };
+	return async (url, init) => {
+		const modifiedInit = {
+			...init,
+			headers: {
+				...init?.headers ? normalizeHeaders(init.headers) : {},
+				"x-goog-api-key": apiKey
+			}
+		};
+		return (customFetch ?? fetch)(url.toString(), modifiedInit);
+	};
 }
-function createGoogleVertex(options = {}) {
-  const apiKey = loadOptionalSetting({
-    settingValue: options.apiKey,
-    environmentVariableName: "GOOGLE_VERTEX_API_KEY"
-  });
-  const loadGoogleVertexProject = () => loadSetting({
-    settingValue: options.project,
-    settingName: "project",
-    environmentVariableName: "GOOGLE_VERTEX_PROJECT",
-    description: "Google Vertex project"
-  });
-  const loadGoogleVertexLocation = () => loadSetting({
-    settingValue: options.location,
-    settingName: "location",
-    environmentVariableName: "GOOGLE_VERTEX_LOCATION",
-    description: "Google Vertex location"
-  });
-  const loadBaseURL = ({ endpoint = false } = {}) => {
-    if (apiKey) {
-      return withoutTrailingSlash(options.baseURL) ?? EXPRESS_MODE_BASE_URL;
-    }
-    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 withoutTrailingSlash(options.baseURL) ?? `https://${getHost()}/v1beta1/projects/${project}/locations/${region}${endpoint ? "" : "/publishers/google"}`;
-  };
-  const createConfig = (name, { endpoint = false } = {}) => {
-    const getHeaders = async () => {
-      const originalHeaders = await resolve6(options.headers ?? {});
-      return withUserAgentSuffix(
-        originalHeaders,
-        `ai-sdk-google-vertex/${VERSION}`
-      );
-    };
-    return {
-      provider: `google.vertex.${name}`,
-      headers: getHeaders,
-      fetch: apiKey ? createExpressModeFetch(apiKey, options.fetch) : options.fetch,
-      baseURL: loadBaseURL({ endpoint })
-    };
-  };
-  const createChatModel = (modelId) => {
-    const endpoint = isEndpointModelId(modelId);
-    if (endpoint && apiKey) {
-      throw new Error(
-        "Google Vertex tuned models do not support Express Mode API keys. Use standard Google Cloud credentials instead."
-      );
-    }
-    return new GoogleLanguageModel2(modelId, {
-      ...createConfig("chat", { endpoint }),
-      generateId: options.generateId ?? generateId,
-      supportedUrls: () => ({
-        "*": [
-          // HTTP URLs:
-          /^https?:\/\/.*$/,
-          // Google Cloud Storage URLs:
-          /^gs:\/\/.*$/
-        ]
-      }),
-      downloadToolResultFiles: {
-        maxBytes: options.toolResultDownloads?.maxBytes ?? 7 * 1024 * 1024,
-        supportsGoogleCloudStorageUrls: true
-      }
-    });
-  };
-  const createInteractionsModel = (modelIdOrAgent) => {
-    if (apiKey) {
-      throw new Error(
-        "Google Vertex Interactions models do not support Express Mode API keys. Use standard Google Cloud credentials instead."
-      );
-    }
-    return new GoogleInteractionsLanguageModel(
-      modelIdOrAgent,
-      {
-        // The Interactions API is a location-scoped resource
-        // (`.../locations/{region}/interactions`), so it uses the
-        // endpoint-style base URL without the `/publishers/google` suffix that
-        // the base-model paths carry.
-        ...createConfig("interactions", { endpoint: true }),
-        generateId: options.generateId ?? generateId
-      }
-    );
-  };
-  const createEmbeddingModel = (modelId) => new GoogleVertexEmbeddingModel(modelId, createConfig("embedding"));
-  const createImageModel = (modelId) => new GoogleVertexImageModel(modelId, {
-    ...createConfig("image"),
-    generateId: options.generateId ?? generateId
-  });
-  const createVideoModel = (modelId) => new GoogleVertexVideoModel(modelId, {
-    ...createConfig("video"),
-    generateId: options.generateId ?? generateId
-  });
-  const createSpeechModel = (modelId) => {
-    if (modelId.startsWith("chirp")) {
-      if (apiKey) {
-        throw new Error(
-          "Google Vertex Chirp speech models do not support Express Mode API keys. Use standard Google Cloud credentials instead."
-        );
-      }
-      const config = createConfig("speech");
-      return new GoogleVertexCloudTTSSpeechModel(modelId, {
-        provider: config.provider,
-        headers: config.headers,
-        fetch: config.fetch
-      });
-    }
-    return 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");
-    if (modelId.startsWith("gemini")) {
-      return new GoogleVertexGeminiTranscriptionModel(modelId, {
-        provider: config.provider,
-        baseURL: loadBaseURL(),
-        headers: config.headers,
-        fetch: config.fetch,
-        webSocket: options.webSocket,
-        project: loadGoogleVertexProject(),
-        location: loadGoogleVertexLocation()
-      });
-    }
-    return new GoogleVertexTranscriptionModel(modelId, {
-      provider: config.provider,
-      headers: config.headers,
-      fetch: config.fetch,
-      project: loadGoogleVertexProject(),
-      location: loadGoogleVertexLocation()
-    });
-  };
-  const provider = function(modelId) {
-    if (new.target) {
-      throw new Error(
-        "The Google Vertex AI model function cannot be called with the new keyword."
-      );
-    }
-    return createChatModel(modelId);
-  };
-  provider.specificationVersion = "v4";
-  provider.languageModel = createChatModel;
-  provider.interactions = createInteractionsModel;
-  provider.embeddingModel = createEmbeddingModel;
-  provider.textEmbeddingModel = createEmbeddingModel;
-  provider.image = createImageModel;
-  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;
+/**
+* Create a Google Vertex AI provider instance.
+*/
+function createGoogleVertex$1(options = {}) {
+	const apiKey = loadOptionalSetting({
+		settingValue: options.apiKey,
+		environmentVariableName: "GOOGLE_VERTEX_API_KEY"
+	});
+	const loadGoogleVertexProject = () => loadSetting({
+		settingValue: options.project,
+		settingName: "project",
+		environmentVariableName: "GOOGLE_VERTEX_PROJECT",
+		description: "Google Vertex project"
+	});
+	const loadGoogleVertexLocation = () => loadSetting({
+		settingValue: options.location,
+		settingName: "location",
+		environmentVariableName: "GOOGLE_VERTEX_LOCATION",
+		description: "Google Vertex location"
+	});
+	const loadBaseURL = ({ endpoint = false } = {}) => {
+		if (apiKey) return withoutTrailingSlash(options.baseURL) ?? EXPRESS_MODE_BASE_URL;
+		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 withoutTrailingSlash(options.baseURL) ?? `https://${getHost()}/v1beta1/projects/${project}/locations/${region}${endpoint ? "" : "/publishers/google"}`;
+	};
+	const createConfig = (name, { endpoint = false } = {}) => {
+		const getHeaders = async () => {
+			const originalHeaders = await resolve(options.headers ?? {});
+			return withUserAgentSuffix(originalHeaders, `ai-sdk-google-vertex/${VERSION}`);
+		};
+		return {
+			provider: `google.vertex.${name}`,
+			headers: getHeaders,
+			fetch: apiKey ? createExpressModeFetch(apiKey, options.fetch) : options.fetch,
+			baseURL: loadBaseURL({ endpoint })
+		};
+	};
+	const createChatModel = (modelId) => {
+		const endpoint = isEndpointModelId(modelId);
+		if (endpoint && apiKey) throw new Error("Google Vertex tuned models do not support Express Mode API keys. Use standard Google Cloud credentials instead.");
+		return new GoogleLanguageModel(modelId, {
+			...createConfig("chat", { endpoint }),
+			generateId: options.generateId ?? generateId,
+			supportedUrls: () => ({ "*": [/^https?:\/\/.*$/, /^gs:\/\/.*$/] }),
+			downloadToolResultFiles: {
+				maxBytes: options.toolResultDownloads?.maxBytes ?? 7340032,
+				supportsGoogleCloudStorageUrls: true
+			}
+		});
+	};
+	const createInteractionsModel = (modelIdOrAgent) => {
+		if (apiKey) throw new Error("Google Vertex Interactions models do not support Express Mode API keys. Use standard Google Cloud credentials instead.");
+		return new GoogleInteractionsLanguageModel(modelIdOrAgent, {
+			...createConfig("interactions", { endpoint: true }),
+			generateId: options.generateId ?? generateId
+		});
+	};
+	const createEmbeddingModel = (modelId) => new GoogleVertexEmbeddingModel(modelId, createConfig("embedding"));
+	const createImageModel = (modelId) => new GoogleVertexImageModel(modelId, {
+		...createConfig("image"),
+		generateId: options.generateId ?? generateId
+	});
+	const createVideoModel = (modelId) => new GoogleVertexVideoModel(modelId, {
+		...createConfig("video"),
+		generateId: options.generateId ?? generateId
+	});
+	const createSpeechModel = (modelId) => {
+		if (modelId.startsWith("chirp")) {
+			if (apiKey) throw new Error("Google Vertex Chirp speech models do not support Express Mode API keys. Use standard Google Cloud credentials instead.");
+			const config = createConfig("speech");
+			return new GoogleVertexCloudTTSSpeechModel(modelId, {
+				provider: config.provider,
+				headers: config.headers,
+				fetch: config.fetch
+			});
+		}
+		return 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");
+		if (modelId.startsWith("gemini")) return new GoogleVertexGeminiTranscriptionModel(modelId, {
+			provider: config.provider,
+			baseURL: loadBaseURL(),
+			headers: config.headers,
+			fetch: config.fetch,
+			webSocket: options.webSocket,
+			project: loadGoogleVertexProject(),
+			location: loadGoogleVertexLocation()
+		});
+		return new GoogleVertexTranscriptionModel(modelId, {
+			provider: config.provider,
+			headers: config.headers,
+			fetch: config.fetch,
+			project: loadGoogleVertexProject(),
+			location: loadGoogleVertexLocation()
+		});
+	};
+	const provider = function(modelId) {
+		if (new.target) throw new Error("The Google Vertex AI model function cannot be called with the new keyword.");
+		return createChatModel(modelId);
+	};
+	provider.specificationVersion = "v4";
+	provider.languageModel = createChatModel;
+	provider.interactions = createInteractionsModel;
+	provider.embeddingModel = createEmbeddingModel;
+	provider.textEmbeddingModel = createEmbeddingModel;
+	provider.image = createImageModel;
+	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/edge/google-vertex-auth-edge.ts
-import {
-  loadOptionalSetting as loadOptionalSetting2,
-  loadSetting as loadSetting2,
-  withUserAgentSuffix as withUserAgentSuffix2,
-  getRuntimeEnvironmentUserAgent
-} from "@ai-sdk/provider-utils";
-var loadCredentials = async () => {
-  try {
-    return {
-      clientEmail: loadSetting2({
-        settingValue: void 0,
-        settingName: "clientEmail",
-        environmentVariableName: "GOOGLE_CLIENT_EMAIL",
-        description: "Google client email"
-      }),
-      privateKey: loadSetting2({
-        settingValue: void 0,
-        settingName: "privateKey",
-        environmentVariableName: "GOOGLE_PRIVATE_KEY",
-        description: "Google private key"
-      }),
-      privateKeyId: loadOptionalSetting2({
-        settingValue: void 0,
-        environmentVariableName: "GOOGLE_PRIVATE_KEY_ID"
-      })
-    };
-  } catch (error) {
-    throw new Error(`Failed to load Google credentials: ${error.message}`);
-  }
+//#endregion
+//#region src/edge/google-vertex-auth-edge.ts
+const loadCredentials = async () => {
+	try {
+		return {
+			clientEmail: loadSetting({
+				settingValue: void 0,
+				settingName: "clientEmail",
+				environmentVariableName: "GOOGLE_CLIENT_EMAIL",
+				description: "Google client email"
+			}),
+			privateKey: loadSetting({
+				settingValue: void 0,
+				settingName: "privateKey",
+				environmentVariableName: "GOOGLE_PRIVATE_KEY",
+				description: "Google private key"
+			}),
+			privateKeyId: loadOptionalSetting({
+				settingValue: void 0,
+				environmentVariableName: "GOOGLE_PRIVATE_KEY_ID"
+			})
+		};
+	} catch (error) {
+		throw new Error(`Failed to load Google credentials: ${error.message}`);
+	}
 };
-var base64url = (str) => {
-  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+const base64url = (str) => {
+	return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
 };
-var importPrivateKey = async (pemKey) => {
-  const pemHeader = "-----BEGIN PRIVATE KEY-----";
-  const pemFooter = "-----END PRIVATE KEY-----";
-  const pemContents = pemKey.replace(pemHeader, "").replace(pemFooter, "").replace(/\s/g, "");
-  const binaryString = atob(pemContents);
-  const binaryData = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    binaryData[i] = binaryString.charCodeAt(i);
-  }
-  return await crypto.subtle.importKey(
-    "pkcs8",
-    binaryData,
-    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
-    true,
-    ["sign"]
-  );
+const importPrivateKey = async (pemKey) => {
+	const pemContents = pemKey.replace("-----BEGIN PRIVATE KEY-----", "").replace("-----END PRIVATE KEY-----", "").replace(/\s/g, "");
+	const binaryString = atob(pemContents);
+	const binaryData = new Uint8Array(binaryString.length);
+	for (let i = 0; i < binaryString.length; i++) binaryData[i] = binaryString.charCodeAt(i);
+	return await crypto.subtle.importKey("pkcs8", binaryData, {
+		name: "RSASSA-PKCS1-v1_5",
+		hash: "SHA-256"
+	}, true, ["sign"]);
 };
-var buildJwt = async (credentials) => {
-  const now = Math.floor(Date.now() / 1e3);
-  const header = {
-    alg: "RS256",
-    typ: "JWT"
-  };
-  if (credentials.privateKeyId) {
-    header.kid = credentials.privateKeyId;
-  }
-  const payload = {
-    iss: credentials.clientEmail,
-    scope: "https://www.googleapis.com/auth/cloud-platform",
-    aud: "https://oauth2.googleapis.com/token",
-    exp: now + 3600,
-    iat: now
-  };
-  const privateKey = await importPrivateKey(credentials.privateKey);
-  const signingInput = `${base64url(JSON.stringify(header))}.${base64url(
-    JSON.stringify(payload)
-  )}`;
-  const encoder = new TextEncoder();
-  const data = encoder.encode(signingInput);
-  const signature = await crypto.subtle.sign(
-    "RSASSA-PKCS1-v1_5",
-    privateKey,
-    data
-  );
-  const signatureBase64 = base64url(
-    String.fromCharCode(...new Uint8Array(signature))
-  );
-  return `${base64url(JSON.stringify(header))}.${base64url(
-    JSON.stringify(payload)
-  )}.${signatureBase64}`;
+const buildJwt = async (credentials) => {
+	const now = Math.floor(Date.now() / 1e3);
+	const header = {
+		alg: "RS256",
+		typ: "JWT"
+	};
+	if (credentials.privateKeyId) header.kid = credentials.privateKeyId;
+	const payload = {
+		iss: credentials.clientEmail,
+		scope: "https://www.googleapis.com/auth/cloud-platform",
+		aud: "https://oauth2.googleapis.com/token",
+		exp: now + 3600,
+		iat: now
+	};
+	const privateKey = await importPrivateKey(credentials.privateKey);
+	const signingInput = `${base64url(JSON.stringify(header))}.${base64url(JSON.stringify(payload))}`;
+	const data = new TextEncoder().encode(signingInput);
+	const signature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", privateKey, data);
+	const signatureBase64 = base64url(String.fromCharCode(...new Uint8Array(signature)));
+	return `${base64url(JSON.stringify(header))}.${base64url(JSON.stringify(payload))}.${signatureBase64}`;
 };
+/**
+* Generate an authentication token for Google Vertex AI in a manner compatible
+* with the Edge runtime.
+*/
 async function generateAuthToken(credentials) {
-  const creds = credentials || await loadCredentials();
-  const jwt = await buildJwt(creds);
-  const response = await fetch("https://oauth2.googleapis.com/token", {
-    method: "POST",
-    headers: withUserAgentSuffix2(
-      { "Content-Type": "application/x-www-form-urlencoded" },
-      `ai-sdk-google-vertex/${VERSION}`,
-      getRuntimeEnvironmentUserAgent()
-    ),
-    body: new URLSearchParams({
-      grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
-      assertion: jwt
-    })
-  });
-  if (!response.ok) {
-    throw new Error(`Token request failed: ${response.statusText}`);
-  }
-  const data = await response.json();
-  return data.access_token;
+	const creds = credentials || await loadCredentials();
+	const jwt = await buildJwt(creds);
+	const response = await fetch("https://oauth2.googleapis.com/token", {
+		method: "POST",
+		headers: withUserAgentSuffix({ "Content-Type": "application/x-www-form-urlencoded" }, `ai-sdk-google-vertex/${VERSION}`, getRuntimeEnvironmentUserAgent()),
+		body: new URLSearchParams({
+			grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+			assertion: jwt
+		})
+	});
+	if (!response.ok) throw new Error(`Token request failed: ${response.statusText}`);
+	return (await response.json()).access_token;
 }
-
-// src/edge/google-vertex-provider-edge.ts
-function createGoogleVertex2(options = {}) {
-  const apiKey = loadOptionalSetting3({
-    settingValue: options.apiKey,
-    environmentVariableName: "GOOGLE_VERTEX_API_KEY"
-  });
-  if (apiKey) {
-    return createGoogleVertex(options);
-  }
-  return createGoogleVertex({
-    ...options,
-    headers: async () => ({
-      Authorization: `Bearer ${await generateAuthToken(
-        options.googleCredentials
-      )}`,
-      ...await resolve7(options.headers)
-    })
-  });
+//#endregion
+//#region src/edge/google-vertex-provider-edge.ts
+function createGoogleVertex(options = {}) {
+	if (loadOptionalSetting({
+		settingValue: options.apiKey,
+		environmentVariableName: "GOOGLE_VERTEX_API_KEY"
+	})) return createGoogleVertex$1(options);
+	return createGoogleVertex$1({
+		...options,
+		headers: async () => ({
+			Authorization: `Bearer ${await generateAuthToken(options.googleCredentials)}`,
+			...await resolve(options.headers)
+		})
+	});
 }
-var googleVertex = createGoogleVertex2();
-export {
-  createGoogleVertex2 as createGoogleVertex,
-  createGoogleVertex2 as createVertex,
-  googleVertex,
-  googleVertex as vertex
-};
+/**
+* Default Google Vertex AI provider instance.
+*/
+const googleVertex = createGoogleVertex();
+//#endregion
+export { createGoogleVertex, createGoogleVertex as createVertex, googleVertex, googleVertex as vertex };
+
 //# sourceMappingURL=index.js.map