@zhivex-ai/vertex 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,8 +1,31 @@
+import { normalizeVertexTranscriptionConfig, transcriptionRequest, transcriptionResponse } from "./transcription.js";
+import { createVertexVirtualTryOnClient } from "./virtual-try-on.js";
+import { createVertexEndpointsClient } from "./endpoints.js";
+import { createVertexGrpcClient } from "./grpc.js";
+import { createVertexResponsesModel } from "./responses.js";
+import { VertexLegacyMultimodalEmbeddingModel } from "./multimodal-embeddings.js";
+import { createVertexInteractionsClient } from "./interactions.js";
+import { createVertexSpecializedClients } from "./specialized.js";
+import { VertexEmbeddingModel, VertexOpenEmbeddingModel } from "./embeddings.js";
+import { createVertexChatModel, isVertexChatModel } from "./chat.js";
 import { createVertexClaudeModel } from "./anthropic.js";
+import { createVertexClaudeClient } from "./token-counting.js";
 import { GoogleAuth } from "google-auth-library";
 import { toJSONSchema } from "zod";
-import { capabilities, groundedCapabilities, imageGenerationCapabilities, isGeminiLiveTranslateModel, musicGenerationCapabilities, realtimeCapabilities, speechCapabilities, transcriptionCapabilities, videoGenerationCapabilities, } from "./capabilities.js";
-import { CallbackRealtimeSession, ConfigurationError, ProviderHTTPError, UnsupportedFeatureError, assertTrustedEndpoint, createMcpToolSet, createProviderAdapter, decodeBase64WithLimit, encodeAudioFrame, encodeMediaFrame, isCallableToolDefinition, isHostedToolDefinition, normalizeFinishReason, openWebSocketConnection, readErrorBodyWithLimit, readJsonWithLimit, streamSSE, toToolSet, toolResultPayload, unsupportedBrowserToken, withRetry, withTimeoutSignal } from "@zhivex-ai/core";
+import { capabilities, groundedCapabilities, imageGenerationCapabilities, isGeminiLiveTranslateModel, isVertexLiveTranscribeModel, musicGenerationCapabilities, realtimeCapabilities, speechCapabilities, transcriptionCapabilities, videoGenerationCapabilities, } from "./capabilities.js";
+import { CallbackRealtimeSession, ConfigurationError, ProviderHTTPError, UnsupportedFeatureError, assertTrustedEndpoint, createMcpToolSet, createProviderAdapter, decodeBase64WithLimit, encodeAudioFrame, encodeMediaFrame, isCallableToolDefinition, isHostedToolDefinition, normalizeFinishReason, openWebSocketConnection, readErrorBodyWithLimit, readJsonWithLimit, streamSSE, toToolSet, toolResultPayload, unsupportedBrowserToken, withRetry, withTimeoutSignal } from "@zhivex-ai/core/provider";
+const vertexApiHost = (location) => location === "global"
+    ? "aiplatform.googleapis.com"
+    : location === "us" || location === "eu"
+        ? `aiplatform.${location}.rep.googleapis.com`
+        : `${encodeVertexPathSegment(location, "Vertex location")}-aiplatform.googleapis.com`;
+// Resource names returned by Google are already project-qualified.
+const vertexResourceURL = (baseURL, name) => {
+    const encoded = encodeVertexResourceName(name, "Vertex resource name");
+    return name.startsWith("projects/")
+        ? `${baseURL.replace(/\/projects\/.*$/, "")}/${encoded}`
+        : `${baseURL}/${encoded}`;
+};
 const encodeVertexPathSegment = (value, label) => {
     if (!value || value === "." || value === ".." || /[\\/?#\s]/.test(value)) {
         throw new ConfigurationError(`${label} must be a non-empty opaque identifier without path separators.`);
@@ -193,7 +216,7 @@ const normalizeBatchJob = (json) => ({
     name: json.name ?? "",
     model: json.model,
     state: json.state ?? json.metadata?.state,
-    done: json.done,
+    done: json.done ?? (["JOB_STATE_SUCCEEDED", "JOB_STATE_FAILED", "JOB_STATE_CANCELLED", "JOB_STATE_EXPIRED", "JOB_STATE_PARTIALLY_SUCCEEDED"].includes(json.state ?? json.metadata?.state)),
     createTime: json.createTime ?? json.create_time ?? json.metadata?.createTime,
     updateTime: json.updateTime ?? json.update_time ?? json.metadata?.updateTime,
     rawResponse: json,
@@ -275,18 +298,33 @@ const appendVertexApiKey = (auth, input) => {
     }
     return new Request(appendQuery(input.url, { key: auth.apiKey }), input);
 };
+const awaitVertexToken = async (getAccessToken, signal) => {
+    signal?.throwIfAborted();
+    const token = Promise.resolve().then(getAccessToken);
+    const accessToken = signal ? await new Promise((resolve, reject) => {
+        const aborted = () => reject(signal.reason);
+        signal.addEventListener("abort", aborted, { once: true });
+        token.then(resolve, reject).finally(() => signal.removeEventListener("abort", aborted));
+        if (signal.aborted)
+            aborted();
+    }) : await token;
+    signal?.throwIfAborted();
+    if (!accessToken)
+        throw new ConfigurationError("Missing Vertex access token.");
+    return accessToken;
+};
 const createVertexAuthenticatedFetch = (fetcher, auth) => (async (input, init) => {
+    const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+    signal?.throwIfAborted();
     const headers = new Headers(input instanceof Request ? input.headers : undefined);
     if (init?.headers) {
         new Headers(init.headers).forEach((value, key) => headers.set(key, value));
     }
     if (auth.type === "bearer") {
-        const accessToken = await auth.getAccessToken();
-        if (!accessToken) {
-            throw new ConfigurationError("Missing Vertex access token.");
-        }
+        const accessToken = await awaitVertexToken(auth.getAccessToken, signal);
         headers.set("authorization", `Bearer ${accessToken}`);
     }
+    signal?.throwIfAborted();
     return fetcher(appendVertexApiKey(auth, input), {
         ...init,
         headers
@@ -382,7 +420,7 @@ const mapTools = (tools) => tools
             .map((tool) => ({
             name: tool.name,
             description: tool.description,
-            parameters: toJSONSchema(tool.schema)
+            parameters: toVertexSchema(toJSONSchema(tool.schema))
         }));
         if (functionDeclarations.length) {
             mappedTools.push({ functionDeclarations });
@@ -395,6 +433,9 @@ const mapTools = (tools) => tools
                 const config = tool.config && typeof tool.config === "object" && !Array.isArray(tool.config)
                     ? { ...tool.config }
                     : {};
+                if (config.enableWidget !== undefined && typeof config.enableWidget !== "boolean") {
+                    throw new ConfigurationError("Vertex Google Maps enableWidget must be boolean.");
+                }
                 delete config.latitude;
                 delete config.longitude;
                 mappedTools.push({ googleMaps: config });
@@ -420,8 +461,8 @@ const mapGoogleMapsRetrievalConfig = (tools) => {
     if (latitude === undefined && longitude === undefined) {
         return undefined;
     }
-    if (typeof latitude !== "number" || typeof longitude !== "number") {
-        throw new ConfigurationError('Provider "vertex" Google Maps grounding requires both numeric latitude and longitude.');
+    if (typeof latitude !== "number" || typeof longitude !== "number" || !Number.isFinite(latitude) || !Number.isFinite(longitude) || Math.abs(latitude) > 90 || Math.abs(longitude) > 180) {
+        throw new ConfigurationError('Provider "vertex" Google Maps grounding requires finite latitude in [-90, 90] and longitude in [-180, 180].');
     }
     return {
         latLng: {
@@ -430,8 +471,11 @@ const mapGoogleMapsRetrievalConfig = (tools) => {
         }
     };
 };
-const mapToolConfig = (toolChoice, tools) => {
+const mapToolConfig = (toolChoice, tools, messages) => {
     const retrievalConfig = mapGoogleMapsRetrievalConfig(tools);
+    // A forced initial call must not prevent answering after its result arrives.
+    if (messages.at(-1)?.role === "tool" && toolChoice !== "none")
+        return retrievalConfig ? { retrievalConfig } : undefined;
     if (!toolChoice || toolChoice === "auto") {
         return retrievalConfig ? { retrievalConfig } : undefined;
     }
@@ -468,7 +512,7 @@ const mapRealtimeProviderOptions = (providerOptions) => providerOptions
     : {};
 const vertexRealtimeURL = (location, apiVersion, providerOptions, override) => {
     const candidate = override ?? (typeof providerOptions?.realtime_url === "string" ? providerOptions.realtime_url : undefined);
-    const host = location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
+    const host = vertexApiHost(location);
     return candidate || `wss://${host}/ws/google.cloud.aiplatform.${apiVersion}.LlmBidiService/BidiGenerateContent`;
 };
 const vertexRealtimeHeaders = (accessToken, providerOptions) => ({
@@ -505,8 +549,7 @@ const mapRealtimeTranslationConfig = (config) => {
         : {};
     const translationConfig = {
         ...providerTranslationConfig,
-        ...(config.translation?.targetLanguage ? { targetLanguageCode: config.translation.targetLanguage } : {}),
-        ...(config.translation?.sourceLanguage ? { sourceLanguageCode: config.translation.sourceLanguage } : {})
+        ...(config.translation?.targetLanguage ? { targetLanguageCode: config.translation.targetLanguage } : {})
     };
     return Object.keys(translationConfig).length ? translationConfig : undefined;
 };
@@ -520,6 +563,9 @@ const assertVertexRealtimeTranslateConfig = (config, modelId) => {
     if (!config.translation?.targetLanguage) {
         throw new UnsupportedFeatureError('Model "vertex/gemini-3.5-live-translate-preview" requires "translation.targetLanguage".');
     }
+    if (config.translation.sourceLanguage !== undefined) {
+        throw new UnsupportedFeatureError("Vertex Live Translate detects the source language automatically; translation.sourceLanguage is not supported.");
+    }
     const tools = toToolSet(config.tools);
     if (tools && Object.keys(tools).length > 0) {
         throw new UnsupportedFeatureError('Model "vertex/gemini-3.5-live-translate-preview" does not support realtime tools.');
@@ -531,15 +577,51 @@ const assertVertexRealtimeTranslateConfig = (config, modelId) => {
         throw new UnsupportedFeatureError('Model "vertex/gemini-3.5-live-translate-preview" does not support realtime system instructions.');
     }
 };
+const liveTranscriptionConfig = (config) => {
+    if (config.inputAudioTranscription === false)
+        throw new UnsupportedFeatureError("Live Transcribe cannot disable input transcription.");
+    const value = normalizeVertexTranscriptionConfig(config.inputAudioTranscription === true ? {} : config.inputAudioTranscription, config.inputTranscription?.language);
+    if (value.wordTimestamp || value.diarization)
+        throw new UnsupportedFeatureError("Live Transcribe does not support word timestamps or diarization.");
+    return value;
+};
 const assertVertexRealtimeConfig = (config, modelId) => {
     assertVertexRealtimeTranslateConfig(config, modelId);
+    if (isVertexLiveTranscribeModel(modelId)) {
+        if (config.mode !== undefined && config.mode !== "transcription")
+            throw new UnsupportedFeatureError("Live Transcribe requires transcription mode.");
+        for (const key of ["instructions", "voice", "reasoning", "translation", "mediaResolution", "affectiveDialog", "proactiveAudio", "outputAudioMediaType", "outputSampleRateHz", "turnDetection", "noiseReduction", "autoResponse"]) {
+            if (config[key] !== undefined)
+                throw new UnsupportedFeatureError(`Live Transcribe does not support ${key}.`);
+        }
+        if (config.outputAudioTranscription)
+            throw new UnsupportedFeatureError("Live Transcribe does not produce output audio transcription.");
+        if (Object.keys(toToolSet(config.tools) ?? {}).length)
+            throw new UnsupportedFeatureError("Live Transcribe does not support tools.");
+        if (config.toolChoice !== undefined && config.toolChoice !== "none")
+            throw new UnsupportedFeatureError("Live Transcribe does not support tool selection.");
+        if (config.inputTranscription && Object.keys(config.inputTranscription).some(key => key !== "language"))
+            throw new UnsupportedFeatureError("Live Transcribe inputTranscription accepts only language; use inputAudioTranscription for native options.");
+        for (const key of ["model", "generationConfig", "generation_config", "inputAudioTranscription", "input_audio_transcription", "systemInstruction", "system_instruction", "tools", "translationConfig", "outputAudioTranscription"]) {
+            if (config.providerOptions?.[key] !== undefined)
+                throw new ConfigurationError(`Live Transcribe does not accept providerOptions.${key}.`);
+        }
+        liveTranscriptionConfig(config);
+    }
     if (config.toolChoice !== undefined && !["auto", "none"].includes(String(config.toolChoice))) {
         throw new UnsupportedFeatureError("Vertex Live supports automatic tool selection or tool disabling, but not required or named tool choice.");
     }
 };
-const vertexRealtimeSetup = (config, modelId) => ({
+const vertexRealtimeSetup = (config, modelResource) => isVertexLiveTranscribeModel(modelResource.split("/").at(-1)) ? {
+    setup: {
+        ...mapRealtimeProviderOptions(config.providerOptions),
+        model: modelResource,
+        generationConfig: { responseModalities: ["TEXT"] },
+        inputAudioTranscription: liveTranscriptionConfig(config)
+    }
+} : ({
     setup: {
-        model: `models/${modelId}`,
+        model: modelResource,
         generationConfig: {
             ...(config.voice
                 ? {
@@ -552,10 +634,11 @@ const vertexRealtimeSetup = (config, modelId) => ({
                     }
                 }
                 : {}),
-            responseModalities: ["AUDIO"],
+            responseModalities: isGeminiLiveTranslateModel(modelResource.split("/").at(-1)) && config.outputAudioTranscription
+                ? ["AUDIO", "TEXT"] : ["AUDIO"],
+            ...(mapRealtimeTranslationConfig(config) ? { translationConfig: mapRealtimeTranslationConfig(config) } : {}),
             ...(mapRealtimeThinkingConfig(config) ? { thinkingConfig: mapRealtimeThinkingConfig(config) } : {})
         },
-        ...(mapRealtimeTranslationConfig(config) ? { translationConfig: mapRealtimeTranslationConfig(config) } : {}),
         ...(mapRealtimeTranscriptionConfig(config.inputAudioTranscription ?? (config.inputTranscription ? true : undefined))
             ? {
                 inputAudioTranscription: mapRealtimeTranscriptionConfig(config.inputAudioTranscription ?? (config.inputTranscription ? true : undefined))
@@ -580,11 +663,44 @@ const vertexRealtimeSetup = (config, modelId) => ({
         ...mapRealtimeProviderOptions(config.providerOptions)
     }
 });
-const parseVertexRealtimeEvent = (payload) => {
+const vertexRealtimeTimeLeftMs = (goAway) => {
+    const milliseconds = goAway.timeLeftMs ?? goAway.time_left_ms;
+    if (typeof milliseconds === "number" && Number.isFinite(milliseconds) && milliseconds >= 0)
+        return milliseconds;
+    const duration = goAway.timeLeft ?? goAway.time_left;
+    if (typeof duration !== "string" || !/^\d+(?:\.\d{1,9})?s$/.test(duration))
+        return undefined;
+    const value = Number(duration.slice(0, -1)) * 1000;
+    return Number.isFinite(value) && value <= Number.MAX_SAFE_INTEGER ? value : undefined;
+};
+const parseVertexRealtimeEvent = (payload, transcriptionOnly = false) => {
     if ("setupComplete" in payload) {
         return [];
     }
     const providerMetadata = sanitizeMediaResponse(payload);
+    const cancellation = payload.toolCallCancellation ?? payload.tool_call_cancellation;
+    if (cancellation !== undefined) {
+        const ids = cancellation && typeof cancellation === "object" ? cancellation.ids : undefined;
+        if (!Array.isArray(ids) || ids.some(id => typeof id !== "string" || !id)) {
+            throw new ConfigurationError("Vertex Live returned invalid tool cancellation IDs.");
+        }
+        return [{ type: "realtime-tool-call-cancellation", toolCallIds: [...new Set(ids)] }];
+    }
+    const liveToolCall = payload.toolCall ?? payload.tool_call;
+    if (liveToolCall && typeof liveToolCall === "object") {
+        const calls = liveToolCall.functionCalls ?? liveToolCall.function_calls;
+        if (!Array.isArray(calls))
+            throw new ConfigurationError("Vertex Live returned an invalid function calls array.");
+        const ids = new Set();
+        return calls.map((call) => {
+            if (!call || typeof call.id !== "string" || !call.id || typeof call.name !== "string" || !call.name
+                || ids.has(call.id) || (call.args !== undefined && (!call.args || typeof call.args !== "object" || Array.isArray(call.args)))) {
+                throw new ConfigurationError("Vertex Live returned an invalid or duplicate function call.");
+            }
+            ids.add(call.id);
+            return { type: "realtime-tool-call", toolCall: { id: call.id, name: call.name, input: (call.args ?? {}) } };
+        });
+    }
     const serverContent = typeof payload.serverContent === "object" && payload.serverContent
         ? payload.serverContent
         : typeof payload.server_content === "object" && payload.server_content
@@ -635,6 +751,11 @@ const parseVertexRealtimeEvent = (payload) => {
                 });
             }
         }
+        const interim = serverContent.interimInputTranscription ?? serverContent.interim_input_transcription;
+        if (transcriptionOnly && interim && typeof interim === "object") {
+            // Interim hypotheses can replace earlier words; they are not text deltas.
+            events.push({ type: "realtime-provider-data", provider: "vertex", data: { type: "vertex_transcription_interim", transcription: sanitizeMediaResponse(interim) } });
+        }
         const inputTranscription = typeof serverContent.inputTranscription === "object" && serverContent.inputTranscription
             ? serverContent.inputTranscription
             : typeof serverContent.input_transcription === "object" && serverContent.input_transcription
@@ -645,7 +766,7 @@ const parseVertexRealtimeEvent = (payload) => {
                 type: "realtime-transcript",
                 text: inputTranscription.text,
                 role: "user",
-                isFinal: Boolean(inputTranscription.finished ?? serverContent.turnComplete ?? serverContent.turn_complete),
+                isFinal: transcriptionOnly || Boolean(inputTranscription.finished ?? serverContent.turnComplete ?? serverContent.turn_complete),
                 providerMetadata
             });
         }
@@ -663,6 +784,13 @@ const parseVertexRealtimeEvent = (payload) => {
                 providerMetadata
             });
         }
+        if (serverContent.interrupted === true) {
+            events.push({
+                type: "realtime-response-complete",
+                reason: "interrupted",
+                providerMetadata
+            });
+        }
         if (serverContent.generationComplete || serverContent.generation_complete) {
             events.push({
                 type: "realtime-response-complete",
@@ -707,11 +835,7 @@ const parseVertexRealtimeEvent = (payload) => {
         return [
             {
                 type: "realtime-go-away",
-                timeLeftMs: typeof goAway.timeLeftMs === "number"
-                    ? goAway.timeLeftMs
-                    : typeof goAway.time_left_ms === "number"
-                        ? goAway.time_left_ms
-                        : undefined,
+                timeLeftMs: vertexRealtimeTimeLeftMs(goAway),
                 providerMetadata
             }
         ];
@@ -727,11 +851,14 @@ const parseVertexRealtimeEvent = (payload) => {
     }
     return [];
 };
-const createVertexRealtimeEventParser = () => {
+const createVertexRealtimeEventParser = (transcriptionOnly = false) => {
     let outputTranscript = "";
     return (payload) => {
         const events = [];
-        for (const event of parseVertexRealtimeEvent(payload)) {
+        for (const event of parseVertexRealtimeEvent(payload, transcriptionOnly)) {
+            if (event.type === "realtime-response-complete" && event.reason === "interrupted") {
+                outputTranscript = "";
+            }
             if (event.type === "realtime-transcript" && event.role === "assistant") {
                 if (event.isFinal) {
                     const completeText = event.text.startsWith(outputTranscript)
@@ -956,27 +1083,47 @@ class VertexContextCachesClient {
         return index >= 0 ? this.baseURL.slice(index + 1) : this.baseURL;
     }
     async create(input) {
-        this.assertModelLocation(input.modelId);
+        const modelId = input.modelId.replace(/^publishers\/google\/models\//, "");
+        this.assertModelLocation(modelId);
+        if (input.ttl !== undefined && input.expireTime !== undefined) {
+            throw new ConfigurationError("Vertex context caches accept either ttl or expireTime, not both.");
+        }
+        for (const key of ["model", "contents", "systemInstruction", "system_instruction", "tools", "displayName", "display_name", "ttl", "expireTime", "expire_time"]) {
+            if (input.providerOptions?.[key] !== undefined) {
+                throw new ConfigurationError(`Vertex context cache providerOptions.${key} conflicts with a dedicated input field.`);
+            }
+        }
+        const nativeOptions = { ...input.providerOptions };
+        if (nativeOptions.kmsKeyName !== undefined) {
+            if (nativeOptions.encryptionSpec !== undefined || nativeOptions.encryption_spec !== undefined) {
+                throw new ConfigurationError("Vertex cache kmsKeyName conflicts with encryptionSpec.");
+            }
+            if (typeof nativeOptions.kmsKeyName !== "string" || !/^projects\/[^/]+\/locations\/[^/]+\/keyRings\/[^/]+\/cryptoKeys\/[^/]+$/.test(nativeOptions.kmsKeyName)) {
+                throw new ConfigurationError("Vertex cache kmsKeyName must identify a Cloud KMS crypto key.");
+            }
+            nativeOptions.encryptionSpec = { kmsKeyName: nativeOptions.kmsKeyName };
+            delete nativeOptions.kmsKeyName;
+        }
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/cachedContents`, {
+            const json = await withRetry(() => this.fetcher(`${this.baseURL}/cachedContents`, {
                 method: "POST",
                 headers: this.headers(),
                 signal,
                 body: JSON.stringify({
-                    model: input.modelId.startsWith("projects/")
-                        ? input.modelId
-                        : `${this.resourceBase()}/publishers/google/models/${input.modelId}`,
+                    model: modelId.startsWith("projects/")
+                        ? modelId
+                        : `${this.resourceBase()}/publishers/google/models/${modelId}`,
                     contents: mapMessages(input.contents),
                     ...(input.system ? { systemInstruction: { parts: [{ text: input.system }] } } : { systemInstruction: systemInstruction(input.contents) }),
                     ...(input.tools ? { tools: mapTools(toToolSet(input.tools)) } : {}),
                     ...(input.displayName ? { displayName: input.displayName } : {}),
                     ...(input.ttl ? { ttl: input.ttl } : {}),
                     ...(input.expireTime ? { expireTime: input.expireTime } : {}),
-                    ...(input.providerOptions ?? {})
+                    ...nativeOptions
                 })
-            }), input);
-            return normalizeCachedContent(await parseJson(response));
+            }).then(parseJson), { ...input, abortSignal: signal });
+            return normalizeCachedContent(json);
         }
         finally {
             cleanup();
@@ -985,8 +1132,28 @@ class VertexContextCachesClient {
     async get(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/${encodeVertexResourceName(input.name, "Vertex cache name")}`, { method: "GET", headers: this.headers(), signal }), input);
-            return normalizeCachedContent(await parseJson(response));
+            const json = await withRetry(() => this.fetcher(vertexResourceURL(this.baseURL, input.name), { method: "GET", headers: this.headers(), signal }).then(parseJson), { ...input, abortSignal: signal });
+            return normalizeCachedContent(json);
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async update(input) {
+        if ((input.ttl !== undefined) === (input.expireTime !== undefined)) {
+            throw new ConfigurationError("Vertex cache update requires exactly one of ttl or expireTime.");
+        }
+        if (input.ttl !== undefined && (!/^\d+(?:\.\d{1,9})?s$/.test(input.ttl) || Number(input.ttl.slice(0, -1)) <= 0)) {
+            throw new ConfigurationError("Vertex cache ttl must be a positive duration in seconds, such as 3600s.");
+        }
+        if (input.expireTime !== undefined && (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/.test(input.expireTime) || !Number.isFinite(Date.parse(input.expireTime)))) {
+            throw new ConfigurationError("Vertex cache expireTime must be an RFC 3339 timestamp.");
+        }
+        const field = input.ttl !== undefined ? "ttl" : "expireTime";
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const json = await withRetry(() => this.fetcher(appendQuery(vertexResourceURL(this.baseURL, input.name), { updateMask: field }), { method: "PATCH", headers: this.headers(), redirect: "error", signal, body: JSON.stringify({ [field]: input[field] }) }).then(parseJson), { ...input, abortSignal: signal });
+            return normalizeCachedContent(json);
         }
         finally {
             cleanup();
@@ -995,12 +1162,11 @@ class VertexContextCachesClient {
     async list(input = {}) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(appendQuery(`${this.baseURL}/cachedContents`, { pageSize: input.pageSize, pageToken: input.pageToken }), {
+            const json = await withRetry(() => this.fetcher(appendQuery(`${this.baseURL}/cachedContents`, { pageSize: input.pageSize, pageToken: input.pageToken }), {
                 method: "GET",
                 headers: this.headers(),
                 signal
-            }), input);
-            const json = await parseJson(response);
+            }).then(parseJson), { ...input, abortSignal: signal });
             return {
                 caches: (json.cachedContents ?? json.cached_contents ?? []).map(normalizeCachedContent),
                 nextPageToken: json.nextPageToken,
@@ -1014,8 +1180,10 @@ class VertexContextCachesClient {
     async delete(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/${encodeVertexResourceName(input.name, "Vertex cache name")}`, { method: "DELETE", headers: this.headers(), signal }), input);
-            const json = await parseJson(response);
+            const json = await withRetry(async () => {
+                const response = await this.fetcher(vertexResourceURL(this.baseURL, input.name), { method: "DELETE", headers: this.headers(), signal });
+                return response.status === 204 ? {} : await parseJson(response);
+            }, { ...input, abortSignal: signal });
             return { name: input.name, rawResponse: json };
         }
         finally {
@@ -1025,105 +1193,94 @@ class VertexContextCachesClient {
 }
 class VertexBatchesClient {
     baseURL;
-    accessToken;
     fetcher;
-    assertModelLocation;
-    constructor(baseURL, accessToken, fetcher, assertModelLocation) {
+    assertAccess;
+    constructor(baseURL, fetcher, assertAccess) {
         this.baseURL = baseURL;
-        this.accessToken = accessToken;
         this.fetcher = fetcher;
-        this.assertModelLocation = assertModelLocation;
+        this.assertAccess = assertAccess;
     }
-    headers() {
-        return {
-            "content-type": "application/json"
-        };
-    }
-    async create(input) {
-        this.assertModelLocation(input.modelId);
+    async request(path, method, input, body) {
+        this.assertAccess();
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(input.modelId, "Vertex model ID")}:batchGenerateContent`, {
-                method: "POST",
-                headers: this.headers(),
-                signal,
-                body: JSON.stringify({
-                    batch: {
-                        ...(input.displayName ? { displayName: input.displayName } : {}),
-                        inputConfig: input.fileName
-                            ? { fileName: input.fileName }
-                            : {
-                                requests: {
-                                    requests: input.requests ?? []
-                                }
-                            },
-                        ...(input.providerOptions ?? {})
-                    }
-                })
-            }), input);
-            return normalizeBatchJob(await parseJson(response));
+            const response = await withRetry(async () => {
+                const result = await this.fetcher(path, {
+                    method, headers: { "content-type": "application/json" }, redirect: "error", signal,
+                    ...(body === undefined ? {} : { body: JSON.stringify(body) })
+                });
+                if (!result.ok)
+                    await parseJson(result);
+                return result;
+            }, { ...input, abortSignal: signal });
+            // Cancel returns Empty; delete returns a long-running operation.
+            if (response.status === 204)
+                return {};
+            return await parseJson(response);
         }
         finally {
             cleanup();
         }
     }
+    async create(input) {
+        this.assertAccess();
+        if (input.requests)
+            throw new UnsupportedFeatureError("Vertex batch jobs require Cloud Storage or BigQuery input; upload inline requests first.");
+        const options = input.providerOptions ?? {};
+        if (input.fileName !== undefined && options.inputConfig !== undefined) {
+            throw new ConfigurationError("Vertex batch input requires either fileName or providerOptions.inputConfig, not both.");
+        }
+        if (input.fileName?.startsWith("bq://") && !/^bq:\/\/[^.\s/]+\.[^.\s/]+\.[^.\s/]+$/.test(input.fileName)) {
+            throw new ConfigurationError("Vertex batch BigQuery input must use bq://project.dataset.table.");
+        }
+        if (input.fileName && !input.fileName.startsWith("gs://") && !input.fileName.startsWith("bq://")) {
+            throw new ConfigurationError("Vertex batch fileName must be a gs:// or bq:// URI, not a Gemini Files API ID.");
+        }
+        const inputConfig = options.inputConfig ?? (input.fileName?.startsWith("gs://")
+            ? { instancesFormat: "jsonl", gcsSource: { uris: [input.fileName] } }
+            : input.fileName ? { instancesFormat: "bigquery", bigquerySource: { inputUri: input.fileName } } : undefined);
+        if (!inputConfig || !options.outputConfig)
+            throw new ConfigurationError("Vertex batch jobs require inputConfig (or fileName) and providerOptions.outputConfig.");
+        const model = input.modelId.startsWith("projects/")
+            ? (encodeVertexResourceName(input.modelId, "Vertex batch model"), input.modelId)
+            : input.modelId.startsWith("claude-") ? `publishers/anthropic/models/${encodeVertexPathSegment(input.modelId, "Vertex Claude model")}`
+                : vertexPublisherResource(input.modelId);
+        const publisher = model.match(/(?:^|\/)publishers\/([^/]+)\/models\//)?.[1];
+        if (publisher && publisher !== "google" && /\/locations\/global\/?$/.test(new URL(this.baseURL).pathname)) {
+            throw new ConfigurationError("Vertex partner batch jobs require a supported regional endpoint; global is not supported. Configure location for the selected model.");
+        }
+        const json = await this.request(`${this.baseURL}/batchPredictionJobs`, "POST", input, {
+            ...options, displayName: input.displayName ?? "zhivex-batch", model, inputConfig
+        });
+        return normalizeBatchJob(json);
+    }
     async get(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/${encodeVertexResourceName(input.name, "Vertex batch name")}`, { method: "GET", headers: this.headers(), signal }), input);
-            return normalizeBatchJob(await parseJson(response));
-        }
-        finally {
-            cleanup();
-        }
+        return normalizeBatchJob(await this.request(vertexResourceURL(this.baseURL, input.name), "GET", input));
     }
     async list(input = {}) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        try {
-            const response = await withRetry(() => this.fetcher(appendQuery(`${this.baseURL}/batches`, { pageSize: input.pageSize, pageToken: input.pageToken }), {
-                method: "GET",
-                headers: this.headers(),
-                signal
-            }), input);
-            const json = await parseJson(response);
-            return {
-                batches: (json.batches ?? []).map(normalizeBatchJob),
-                nextPageToken: json.nextPageToken,
-                rawResponse: json
-            };
-        }
-        finally {
-            cleanup();
-        }
+        const json = await this.request(appendQuery(`${this.baseURL}/batchPredictionJobs`, {
+            pageSize: input.pageSize, pageToken: input.pageToken,
+            filter: typeof input.providerOptions?.filter === "string" ? input.providerOptions.filter : undefined
+        }), "GET", input);
+        return { batches: (json.batchPredictionJobs ?? []).map(normalizeBatchJob), nextPageToken: json.nextPageToken, rawResponse: json };
     }
     async cancel(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/${encodeVertexResourceName(input.name, "Vertex batch name")}:cancel`, {
-                method: "POST",
-                headers: this.headers(),
-                signal,
-                body: JSON.stringify(input.providerOptions ?? {})
-            }), input);
-            return normalizeBatchJob(await parseJson(response));
-        }
-        finally {
-            cleanup();
-        }
+        await this.request(`${vertexResourceURL(this.baseURL, input.name)}:cancel`, "POST", input, {});
+        // Cancellation is asynchronous; report the actual job state.
+        return this.get(input);
     }
     async delete(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/${encodeVertexResourceName(input.name, "Vertex batch name")}:delete`, { method: "POST", headers: this.headers(), signal }), input);
-            const json = await parseJson(response);
-            return { name: input.name, rawResponse: json };
-        }
-        finally {
-            cleanup();
-        }
+        const json = await this.request(vertexResourceURL(this.baseURL, input.name), "DELETE", input);
+        return { name: input.name, rawResponse: json };
     }
 }
 const vertexPublisherResource = (modelId) => {
+    if (/^(?:projects\/[^/]+\/locations\/[^/]+\/)?endpoints\/[^/]+$/.test(modelId)) {
+        return encodeVertexResourceName(modelId, "Vertex endpoint");
+    }
+    if (modelId.startsWith("endpoints/") || modelId.startsWith("projects/")) {
+        throw new ConfigurationError("Vertex prediction endpoint must use endpoints/<id> or projects/<project>/locations/<location>/endpoints/<id>.");
+    }
     if (modelId.startsWith("publishers/")) {
         const segments = modelId.split("/");
         if (segments.length !== 4 || segments[2] !== "models") {
@@ -1131,6 +1288,10 @@ const vertexPublisherResource = (modelId) => {
         }
         return `publishers/${encodeVertexPathSegment(segments[1], "Vertex publisher")}/models/${encodeVertexPathSegment(segments[3], "Vertex model ID")}`;
     }
+    if (/^[^/]+\/[^/]+$/.test(modelId)) {
+        const [publisher, model] = modelId.split("/");
+        return `publishers/${encodeVertexPathSegment(publisher, "Vertex publisher")}/models/${encodeVertexPathSegment(model, "Vertex model ID")}`;
+    }
     return `publishers/google/models/${encodeVertexPathSegment(modelId, "Vertex model ID")}`;
 };
 class VertexPredictionModel {
@@ -1157,27 +1318,38 @@ class VertexPredictionModel {
         };
     }
     url(action) {
-        return `${this.baseURL}/${vertexPublisherResource(this.modelId)}:${encodeVertexPathSegment(action, "Vertex prediction action")}`;
+        const resource = vertexPublisherResource(this.modelId);
+        const base = this.modelId.startsWith("projects/") ? this.baseURL.replace(/\/projects\/.*$/, "") : this.baseURL;
+        return `${base}/${resource}:${encodeVertexPathSegment(action, "Vertex prediction action")}`;
     }
     body(input) {
-        return input.body ?? {
+        if (input.body !== undefined)
+            return input.body;
+        const nativeOptions = { ...input.providerOptions };
+        delete nativeOptions.action;
+        for (const key of ["instances", "parameters"]) {
+            if (input[key] !== undefined && nativeOptions[key] !== undefined) {
+                throw new ConfigurationError(`Vertex prediction providerOptions.${key} conflicts with a dedicated input field.`);
+            }
+        }
+        return {
             ...(input.instances ? { instances: input.instances } : {}),
             ...(input.parameters ? { parameters: input.parameters } : {}),
-            ...(input.providerOptions ?? {})
+            ...nativeOptions
         };
     }
     async predictRaw(input) {
         const action = typeof input.providerOptions?.action === "string" ? input.providerOptions.action : "predict";
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(this.url(action), {
+            const json = await withRetry(() => this.fetcher(this.url(action), {
                 method: "POST",
                 redirect: "error",
                 headers: this.headers(),
                 signal,
                 body: JSON.stringify(this.body(input))
-            }), input);
-            return normalizePredictionResult(await parseJson(response));
+            }).then(parseJson), { ...input, abortSignal: signal });
+            return normalizePredictionResult(json);
         }
         finally {
             cleanup();
@@ -1186,14 +1358,14 @@ class VertexPredictionModel {
     async rawPredict(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(this.url("rawPredict"), {
+            const json = await withRetry(() => this.fetcher(this.url("rawPredict"), {
                 method: "POST",
                 redirect: "error",
                 headers: this.headers(),
                 signal,
                 body: JSON.stringify(this.body(input))
-            }), input);
-            return normalizePredictionResult(await parseJson(response));
+            }).then(parseJson), { ...input, abortSignal: signal });
+            return normalizePredictionResult(json);
         }
         finally {
             cleanup();
@@ -1202,14 +1374,14 @@ class VertexPredictionModel {
     async invoke(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(this.url("invoke"), {
+            const json = await withRetry(() => this.fetcher(this.url("invoke"), {
                 method: "POST",
                 redirect: "error",
                 headers: this.headers(),
                 signal,
                 body: JSON.stringify(this.body(input))
-            }), input);
-            return normalizePredictionResult(await parseJson(response));
+            }).then(parseJson), { ...input, abortSignal: signal });
+            return normalizePredictionResult(json);
         }
         finally {
             cleanup();
@@ -1218,23 +1390,26 @@ class VertexPredictionModel {
     async predictLongRunning(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(this.url("predictLongRunning"), {
+            const json = await withRetry(() => this.fetcher(this.url("predictLongRunning"), {
                 method: "POST",
                 redirect: "error",
                 headers: this.headers(),
                 signal,
                 body: JSON.stringify(this.body(input))
-            }), input);
-            return normalizeOperation(await parseJson(response));
+            }).then(parseJson), { ...input, abortSignal: signal });
+            return normalizeOperation(json);
         }
         finally {
             cleanup();
         }
     }
     async fetchPredictionOperation(input) {
+        if (input.providerOptions?.operationName !== undefined || input.providerOptions?.operation_name !== undefined) {
+            throw new ConfigurationError("Vertex prediction operationName must be supplied through name.");
+        }
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(this.url("fetchPredictOperation"), {
+            const json = await withRetry(() => this.fetcher(this.url("fetchPredictOperation"), {
                 method: "POST",
                 redirect: "error",
                 headers: this.headers(),
@@ -1243,8 +1418,8 @@ class VertexPredictionModel {
                     operationName: input.name,
                     ...(input.providerOptions ?? {})
                 })
-            }), input);
-            return normalizeOperation(await parseJson(response));
+            }).then(parseJson), { ...input, abortSignal: signal });
+            return normalizeOperation(json);
         }
         finally {
             cleanup();
@@ -1277,7 +1452,7 @@ class VertexLanguageModel {
         assertCurrentGeminiGenerateInput("vertex", this.modelId, input);
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(this.url("generateContent"), {
+            const json = await withRetry(() => this.fetcher(this.url("generateContent"), {
                 method: "POST",
                 headers: this.headers(),
                 signal,
@@ -1286,11 +1461,10 @@ class VertexLanguageModel {
                     contents: mapMessages(input.messages),
                     systemInstruction: systemInstruction(input.messages),
                     tools: mapTools(input.tools),
-                    toolConfig: mapToolConfig(input.toolChoice, input.tools),
+                    toolConfig: mapToolConfig(input.toolChoice, input.tools, input.messages),
                     generationConfig: generationConfig(this.modelId, input)
                 })
-            }), input);
-            const json = await parseJson(response);
+            }).then(parseJson), { ...input, abortSignal: signal });
             const candidate = json.candidates?.[0];
             const assistantMessage = parseAssistantMessage(candidate);
             return {
@@ -1321,10 +1495,17 @@ class VertexLanguageModel {
                 contents: mapMessages(input.messages),
                 systemInstruction: systemInstruction(input.messages),
                 tools: mapTools(input.tools),
-                toolConfig: mapToolConfig(input.toolChoice, input.tools),
+                toolConfig: mapToolConfig(input.toolChoice, input.tools, input.messages),
                 generationConfig: generationConfig(this.modelId, input)
             })
-        }), input);
+        }).then(async (response) => {
+            if (!response.ok)
+                await parseJson(response);
+            return response;
+        }), { ...input, abortSignal: signal }).catch((error) => {
+            cleanup();
+            throw error;
+        });
         return (async function* () {
             try {
                 for await (const event of streamSSE(response)) {
@@ -1365,57 +1546,6 @@ class VertexLanguageModel {
         })();
     }
 }
-class VertexEmbeddingModel {
-    modelId;
-    baseURL;
-    accessToken;
-    fetcher;
-    provider = "vertex";
-    capabilities = capabilities;
-    constructor(modelId, baseURL, accessToken, fetcher) {
-        this.modelId = modelId;
-        this.baseURL = baseURL;
-        this.accessToken = accessToken;
-        this.fetcher = fetcher;
-    }
-    url() {
-        return `${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:predict`;
-    }
-    headers() {
-        return {
-            "content-type": "application/json"
-        };
-    }
-    async embed(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        const values = input.values.map((value) => {
-            if (typeof value !== "string") {
-                throw new UnsupportedFeatureError('Provider "vertex" does not support multimodal embedding values.');
-            }
-            return value;
-        });
-        try {
-            const response = await withRetry(() => this.fetcher(this.url(), {
-                method: "POST",
-                headers: this.headers(),
-                signal,
-                body: JSON.stringify({
-                    instances: values.map((value) => ({
-                        content: value
-                    }))
-                })
-            }), input);
-            const json = await parseJson(response);
-            return {
-                embeddings: (json.predictions ?? []).map((prediction) => prediction.embeddings?.values ?? []),
-                rawResponse: json
-            };
-        }
-        finally {
-            cleanup();
-        }
-    }
-}
 class VertexTranscriptionModel {
     modelId;
     baseURL;
@@ -1438,39 +1568,16 @@ class VertexTranscriptionModel {
         };
     }
     async transcribe(input) {
+        const body = transcriptionRequest(this.modelId, input, toBase64(input.audio.data));
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(this.url(), {
+            const json = await withRetry(() => this.fetcher(this.url(), {
                 method: "POST",
                 headers: this.headers(),
                 signal,
-                body: JSON.stringify({
-                    contents: [
-                        {
-                            role: "user",
-                            parts: [
-                                {
-                                    inlineData: {
-                                        mimeType: input.audio.mediaType,
-                                        data: toBase64(input.audio.data)
-                                    }
-                                },
-                                {
-                                    text: input.prompt ??
-                                        `Transcribe this audio${input.language ? ` in ${input.language}` : ""}. Return only the transcript.`
-                                }
-                            ]
-                        }
-                    ],
-                    ...input.providerOptions
-                })
-            }), input);
-            const json = await parseJson(response);
-            const text = json.candidates?.[0]?.content?.parts?.find((part) => typeof part.text === "string")?.text ?? "";
-            return {
-                text,
-                rawResponse: json
-            };
+                body: JSON.stringify(body)
+            }).then(parseJson), { ...input, abortSignal: signal });
+            return transcriptionResponse(json);
         }
         finally {
             cleanup();
@@ -1501,7 +1608,7 @@ class VertexSpeechModel {
     async generateSpeech(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(this.url(), {
+            const json = await withRetry(() => this.fetcher(this.url(), {
                 method: "POST",
                 headers: this.headers(),
                 signal,
@@ -1519,8 +1626,7 @@ class VertexSpeechModel {
                     },
                     ...input.providerOptions
                 })
-            }), input);
-            const json = await parseJson(response);
+            }).then(parseJson), { ...input, abortSignal: signal });
             const audioPart = json.candidates?.[0]?.content?.parts?.find((part) => part.inlineData?.data);
             return {
                 audio: decodeMedia(audioPart?.inlineData?.data ?? "", "models.generateContent"),
@@ -1552,7 +1658,11 @@ class VertexSpeechModel {
                 },
                 ...input.providerOptions
             })
-        }), input);
+        }).then(async (response) => {
+            if (!response.ok)
+                await parseJson(response);
+            return response;
+        }), { ...input, abortSignal: signal }).catch(error => { cleanup(); throw error; });
         return (async function* () {
             try {
                 for await (const event of streamSSE(response)) {
@@ -1601,7 +1711,18 @@ class VertexImageGenerationModel {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
             if (isImagenModel(this.modelId)) {
-                const response = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:predict`, {
+                if (input.images?.length)
+                    throw new UnsupportedFeatureError("Imagen text-to-image generation does not accept images; use the native editing referenceImages contract through predictionModel().");
+                const outputOptions = input.providerOptions?.outputOptions;
+                if (input.outputMimeType !== undefined && outputOptions !== undefined &&
+                    (!outputOptions || typeof outputOptions !== "object" || Array.isArray(outputOptions))) {
+                    throw new ConfigurationError("Imagen providerOptions.outputOptions must be an object.");
+                }
+                const nativeOutputOptions = outputOptions;
+                if (input.outputMimeType !== undefined && nativeOutputOptions?.mimeType !== undefined &&
+                    nativeOutputOptions.mimeType !== input.outputMimeType)
+                    throw new ConfigurationError("Conflicting Imagen output MIME types.");
+                const json = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:predict`, {
                     method: "POST",
                     headers: this.headers(),
                     signal,
@@ -1612,16 +1733,15 @@ class VertexImageGenerationModel {
                             }
                         ],
                         parameters: {
-                            ...(input.negativePrompt ? { negativePrompt: input.negativePrompt, negative_prompt: input.negativePrompt } : {}),
-                            ...(input.count ? { sampleCount: input.count, number_of_images: input.count } : {}),
-                            ...(input.aspectRatio ? { aspectRatio: input.aspectRatio, aspect_ratio: input.aspectRatio } : {}),
-                            ...(input.size ? { sampleImageSize: input.size, sample_image_size: input.size } : {}),
-                            ...(input.outputMimeType ? { outputMimeType: input.outputMimeType, output_mime_type: input.outputMimeType } : {}),
-                            ...input.providerOptions
+                            ...input.providerOptions,
+                            ...(input.negativePrompt ? { negativePrompt: input.negativePrompt } : {}),
+                            ...(input.count ? { sampleCount: input.count } : {}),
+                            ...(input.aspectRatio ? { aspectRatio: input.aspectRatio } : {}),
+                            ...(input.size ? { sampleImageSize: input.size } : {}),
+                            ...(input.outputMimeType ? { outputOptions: { ...nativeOutputOptions, mimeType: input.outputMimeType } } : {})
                         }
                     })
-                }), input);
-                const json = await parseJson(response);
+                }).then(parseJson), { ...input, abortSignal: signal });
                 const images = (Array.isArray(json.predictions) ? json.predictions : [])
                     .map((prediction) => ({
                     data: prediction.bytesBase64Encoded || prediction.imageBytes
@@ -1639,7 +1759,7 @@ class VertexImageGenerationModel {
                 };
             }
             const { generationConfig, providerOptions } = splitGenerationConfig(input.providerOptions);
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:generateContent`, {
+            const json = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:generateContent`, {
                 method: "POST",
                 headers: this.headers(),
                 signal,
@@ -1669,8 +1789,7 @@ class VertexImageGenerationModel {
                         ...generationConfig
                     }
                 })
-            }), input);
-            const json = await parseJson(response);
+            }).then(parseJson), { ...input, abortSignal: signal });
             const { media, text } = collectInlineMedia(json, input.outputMimeType ?? "image/png", "models.generateContent");
             return {
                 images: media,
@@ -1688,13 +1807,15 @@ class VertexMusicGenerationModel {
     baseURL;
     accessToken;
     fetcher;
+    interactions;
     provider = "vertex";
     capabilities = musicGenerationCapabilities;
-    constructor(modelId, baseURL, accessToken, fetcher) {
+    constructor(modelId, baseURL, accessToken, fetcher, interactions) {
         this.modelId = modelId;
         this.baseURL = baseURL;
         this.accessToken = accessToken;
         this.fetcher = fetcher;
+        this.interactions = interactions;
     }
     headers() {
         return {
@@ -1702,10 +1823,33 @@ class VertexMusicGenerationModel {
         };
     }
     async generateMusic(input) {
+        if (this.modelId.startsWith("lyria-3-")) {
+            if (!this.interactions)
+                throw new ConfigurationError("Lyria 3 requires Vertex Interactions.");
+            if (input.negativePrompt || input.outputMimeType)
+                throw new UnsupportedFeatureError("Vertex Lyria 3 does not expose negativePrompt or outputMimeType; describe the desired music in prompt.");
+            const content = [{ type: "text", text: input.prompt }];
+            for (const image of input.images ?? []) {
+                if (!image.mediaType.startsWith("image/") || (image.data === undefined) === (image.uri === undefined))
+                    throw new ConfigurationError("Lyria 3 image input requires exactly one data or uri and an image media type.");
+                const part = mediaInputToPart(image);
+                content.push({ type: "image", mime_type: image.mediaType,
+                    ...(part.inlineData ? { data: part.inlineData.data } : { uri: image.uri }) });
+            }
+            const result = await this.interactions.create({ ...input, modelId: this.modelId, input: content, background: false });
+            const audio = (result.outputs ?? []).filter((output) => !!output && typeof output === "object" && "type" in output && output.type === "audio").map((output) => {
+                if (typeof output.data !== "string")
+                    throw new ConfigurationError("Lyria 3 returned audio without inline data; use interactions for asynchronous output.");
+                return { data: decodeMedia(output.data, "interactions"), mediaType: typeof output.mime_type === "string" ? output.mime_type : "audio/mpeg" };
+            });
+            if (result.status !== "completed" || !audio.length)
+                throw new ConfigurationError("Lyria 3 did not return completed audio; use interactions to inspect the operation.");
+            return { audio, text: result.outputText, rawResponse: sanitizeMediaResponse(result.rawResponse) };
+        }
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
             if (this.modelId === "lyria-002") {
-                const response = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:predict`, {
+                const json = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:predict`, {
                     method: "POST",
                     headers: this.headers(),
                     signal,
@@ -1720,8 +1864,7 @@ class VertexMusicGenerationModel {
                             ...input.providerOptions
                         }
                     })
-                }), input);
-                const json = await parseJson(response);
+                }).then(parseJson), { ...input, abortSignal: signal });
                 return {
                     audio: (Array.isArray(json.predictions) ? json.predictions : []).map((prediction) => ({
                         data: decodeMedia(prediction.audioContent ?? "", "models.predict"),
@@ -1732,7 +1875,7 @@ class VertexMusicGenerationModel {
                 };
             }
             const { generationConfig, providerOptions } = splitGenerationConfig(input.providerOptions);
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:generateContent`, {
+            const json = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:generateContent`, {
                 method: "POST",
                 headers: this.headers(),
                 signal,
@@ -1753,8 +1896,7 @@ class VertexMusicGenerationModel {
                         ...generationConfig
                     }
                 })
-            }), input);
-            const json = await parseJson(response);
+            }).then(parseJson), { ...input, abortSignal: signal });
             const { media, text } = collectInlineMedia(json, input.outputMimeType ?? "audio/mpeg", "models.generateContent");
             return {
                 audio: media,
@@ -1772,13 +1914,15 @@ class VertexVideoGenerationModel {
     baseURL;
     accessToken;
     fetcher;
+    interactions;
     provider = "vertex";
     capabilities = videoGenerationCapabilities;
-    constructor(modelId, baseURL, accessToken, fetcher) {
+    constructor(modelId, baseURL, accessToken, fetcher, interactions) {
         this.modelId = modelId;
         this.baseURL = baseURL;
         this.accessToken = accessToken;
         this.fetcher = fetcher;
+        this.interactions = interactions;
     }
     headers() {
         return {
@@ -1786,11 +1930,58 @@ class VertexVideoGenerationModel {
         };
     }
     async generateVideo(input) {
+        if (this.modelId.startsWith("gemini-omni-")) {
+            if (!this.interactions)
+                throw new ConfigurationError("Gemini Omni video requires Vertex Interactions.");
+            if (input.count !== undefined && input.count !== 1)
+                throw new UnsupportedFeatureError("Gemini Omni generates one video per interaction.");
+            if (input.pollIntervalMs !== undefined)
+                throw new UnsupportedFeatureError("Gemini Omni synchronous generation does not poll; use interactions for asynchronous workflows.");
+            if (input.negativePrompt !== undefined)
+                throw new UnsupportedFeatureError("Gemini Omni does not expose negativePrompt; describe the desired video in prompt.");
+            if (input.durationSeconds !== undefined && (!Number.isInteger(input.durationSeconds) || input.durationSeconds < 3 || input.durationSeconds > 10))
+                throw new ConfigurationError("Gemini Omni durationSeconds must be an integer from 3 to 10.");
+            if (input.aspectRatio !== undefined && !["16:9", "9:16"].includes(input.aspectRatio))
+                throw new ConfigurationError("Gemini Omni aspectRatio must be 16:9 or 9:16.");
+            if (input.outputStorageUri !== undefined && !/^gs:\/\/[^/\s]+\/[^\s]*$/.test(input.outputStorageUri))
+                throw new ConfigurationError("Gemini Omni outputStorageUri must be a gs:// bucket path.");
+            const options = input.providerOptions ?? {};
+            for (const key of Object.keys(options))
+                if (key !== "resolution")
+                    throw new UnsupportedFeatureError(`Gemini Omni video does not expose providerOptions.${key}; use interactions for advanced video workflows.`);
+            const resolutions = this.modelId.startsWith("gemini-omni-1.1-") ? ["360p", "720p", "1080p", "4k"] : ["720p"];
+            if (options.resolution !== undefined && !resolutions.includes(String(options.resolution)))
+                throw new ConfigurationError("Unsupported Gemini Omni video resolution for this model.");
+            const content = [{ type: "text", text: input.prompt }];
+            if (input.image) {
+                if (!input.image.mediaType.startsWith("image/") || (input.image.data === undefined) === (input.image.uri === undefined))
+                    throw new ConfigurationError("Gemini Omni image requires an image MIME type and exactly one data or uri.");
+                const part = mediaInputToPart(input.image);
+                content.push({ type: "image", mime_type: input.image.mediaType,
+                    ...(part.inlineData ? { data: part.inlineData.data } : { uri: input.image.uri }) });
+            }
+            const result = await this.interactions.create({ modelId: this.modelId, input: content,
+                responseFormat: [{ type: "video", ...(input.outputStorageUri ? { delivery: "uri", gcs_uri: input.outputStorageUri } : {}),
+                        ...(input.aspectRatio ? { aspect_ratio: input.aspectRatio } : {}),
+                        ...(input.durationSeconds !== undefined ? { duration: `${input.durationSeconds}s` } : {}),
+                        ...(options.resolution ? { resolution: String(options.resolution) } : {}) }],
+                generationConfig: { video_config: { task: input.image ? "image_to_video" : "text_to_video" } },
+                background: false, store: false, abortSignal: input.abortSignal, timeoutMs: input.timeoutMs ?? 600_000,
+                maxRetries: input.maxRetries, retryBackoffMs: input.retryBackoffMs });
+            const videos = (result.outputs ?? []).filter((output) => !!output && typeof output === "object" && "type" in output && output.type === "video").map((output) => ({
+                ...(typeof output.data === "string" ? { data: decodeMedia(output.data, "interactions") } : {}),
+                ...(typeof output.uri === "string" ? { uri: output.uri } : {}),
+                mediaType: typeof output.mime_type === "string" ? output.mime_type : "video/mp4"
+            }));
+            if (result.status !== "completed" || !videos.length || videos.some((video) => !video.data?.length && !video.uri))
+                throw new ConfigurationError("Gemini Omni did not return completed video; use interactions for asynchronous workflows.");
+            return { videos, rawResponse: sanitizeMediaResponse(result.rawResponse) };
+        }
         const timeoutMs = input.timeoutMs ?? 600_000;
         const { signal, cleanup } = withTimeoutSignal({ ...input, timeoutMs });
         const startedAt = Date.now();
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:predictLongRunning`, {
+            const json = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:predictLongRunning`, {
                 method: "POST",
                 headers: this.headers(),
                 signal,
@@ -1810,8 +2001,8 @@ class VertexVideoGenerationModel {
                         ...input.providerOptions
                     }
                 })
-            }), input);
-            let operation = await parseJson(response);
+            }).then(parseJson), { ...input, abortSignal: signal });
+            let operation = json;
             const operationName = operation.name;
             const pollIntervalMs = input.pollIntervalMs ?? 10_000;
             while (!operation.done) {
@@ -1819,15 +2010,15 @@ class VertexVideoGenerationModel {
                     throw new Error(`Vertex video generation timed out after ${timeoutMs}ms.`);
                 }
                 await sleep(pollIntervalMs, signal);
-                const pollResponse = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:fetchPredictOperation`, {
+                const pollResult = await withRetry(() => this.fetcher(`${this.baseURL}/publishers/google/models/${encodeVertexPathSegment(this.modelId, "Vertex model ID")}:fetchPredictOperation`, {
                     method: "POST",
                     headers: this.headers(),
                     signal,
                     body: JSON.stringify({
                         operationName
                     })
-                }), input);
-                operation = await parseJson(pollResponse);
+                }).then(parseJson), { ...input, abortSignal: signal });
+                operation = pollResult;
             }
             return {
                 videos: collectVideos(operation, "models.predictLongRunning"),
@@ -1866,7 +2057,7 @@ class VertexGroundedLanguageModel {
         assertCurrentGeminiGenerateInput("vertex", this.modelId, input);
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(this.url(), {
+            const json = await withRetry(() => this.fetcher(this.url(), {
                 method: "POST",
                 headers: this.headers(),
                 signal,
@@ -1882,8 +2073,7 @@ class VertexGroundedLanguageModel {
                         reasoning: input.reasoning
                     })
                 })
-            }), input);
-            const json = await parseJson(response);
+            }).then(parseJson), { ...input, abortSignal: signal });
             const candidate = json.candidates?.[0];
             const assistantMessage = parseAssistantMessage(candidate);
             return {
@@ -1894,6 +2084,7 @@ class VertexGroundedLanguageModel {
                 sources: extractGroundingSources(candidate),
                 finishReason: normalizeFinishReason(candidate?.finishReason),
                 providerFinishReason: candidate?.finishReason,
+                usage: normalizeGenerateContentUsage(json.usageMetadata ?? json.usage_metadata),
                 rawResponse: json
             };
         }
@@ -1910,9 +2101,10 @@ class VertexRealtimeModel {
     connectionFactory;
     realtimeURL;
     allowUnsafeEndpoints;
+    projectResource;
     provider = "vertex";
     capabilities;
-    constructor(modelId, auth, location, apiVersion, connectionFactory, realtimeURL, allowUnsafeEndpoints = false) {
+    constructor(modelId, auth, location, apiVersion, connectionFactory, realtimeURL, allowUnsafeEndpoints = false, projectResource) {
         this.modelId = modelId;
         this.auth = auth;
         this.location = location;
@@ -1920,6 +2112,7 @@ class VertexRealtimeModel {
         this.connectionFactory = connectionFactory;
         this.realtimeURL = realtimeURL;
         this.allowUnsafeEndpoints = allowUnsafeEndpoints;
+        this.projectResource = projectResource;
         this.capabilities = realtimeCapabilities(modelId);
     }
     async connect(config = {}, options) {
@@ -1927,10 +2120,22 @@ class VertexRealtimeModel {
         if (this.auth.type === "api-key") {
             throw new UnsupportedFeatureError('Provider "vertex" realtime sessions require accessToken or getAccessToken auth.');
         }
-        const accessToken = await this.auth.getAccessToken();
-        if (!accessToken) {
-            throw new ConfigurationError("Missing Vertex access token.");
+        if (!this.projectResource)
+            throw new ConfigurationError("Vertex Live requires a project ID or project-scoped baseURL.");
+        const modelResource = `${this.projectResource}/publishers/google/models/${this.modelId}`;
+        const started = performance.now();
+        const authDeadline = withTimeoutSignal({ timeoutMs: options?.timeoutMs, abortSignal: options?.signal });
+        let accessToken;
+        try {
+            accessToken = await awaitVertexToken(this.auth.getAccessToken, authDeadline.signal);
         }
+        finally {
+            authDeadline.cleanup();
+        }
+        const remainingTimeout = options?.timeoutMs === undefined ? undefined : Math.floor(options.timeoutMs - (performance.now() - started));
+        if (remainingTimeout !== undefined && remainingTimeout <= 0)
+            throw new DOMException("The operation timed out.", "TimeoutError");
+        options?.signal?.throwIfAborted();
         const providerOptions = (config.providerOptions ?? {});
         const expectedRealtimeURL = vertexRealtimeURL(this.location, this.apiVersion, undefined, this.realtimeURL);
         const realtimeEndpoint = assertTrustedEndpoint(vertexRealtimeURL(this.location, this.apiVersion, providerOptions, this.realtimeURL), {
@@ -1939,7 +2144,8 @@ class VertexRealtimeModel {
             allowedHosts: [new URL(expectedRealtimeURL).hostname],
             allowUnsafe: this.allowUnsafeEndpoints
         }).toString();
-        const connection = await (this.connectionFactory ?? openWebSocketConnection)(realtimeEndpoint, vertexRealtimeHeaders(accessToken, providerOptions), options);
+        const connection = await (this.connectionFactory ?? openWebSocketConnection)(realtimeEndpoint, vertexRealtimeHeaders(accessToken, providerOptions), { ...options, timeoutMs: remainingTimeout });
+        let inputMuted = false;
         const session = new CallbackRealtimeSession({
             provider: this.provider,
             modelId: this.modelId,
@@ -1948,9 +2154,9 @@ class VertexRealtimeModel {
             connection,
             initializationTimeoutMs: options?.timeoutMs,
             callbacks: {
-                parseEvent: createVertexRealtimeEventParser(),
+                parseEvent: createVertexRealtimeEventParser(isVertexLiveTranscribeModel(this.modelId)),
                 isReadyPayload: (payload) => "setupComplete" in payload || "setup_complete" in payload,
-                buildAudioPayloads: (frame) => [
+                buildAudioPayloads: (frame) => inputMuted ? [] : [
                     {
                         realtimeInput: {
                             audio: {
@@ -1961,23 +2167,23 @@ class VertexRealtimeModel {
                     }
                 ],
                 buildMediaPayloads: (frame) => {
-                    if (isGeminiLiveTranslateModel(this.modelId)) {
-                        throw new UnsupportedFeatureError('Model "vertex/gemini-3.5-live-translate-preview" only supports audio input.');
+                    if (isGeminiLiveTranslateModel(this.modelId) || isVertexLiveTranscribeModel(this.modelId)) {
+                        throw new UnsupportedFeatureError(`Model "vertex/${this.modelId}" only supports audio input.`);
                     }
                     return [
                         {
                             realtimeInput: {
-                                media: {
-                                    mimeType: frame.mediaType,
-                                    data: encodeMediaFrame(frame)
-                                }
+                                mediaChunks: [{
+                                        mimeType: frame.mediaType,
+                                        data: encodeMediaFrame(frame)
+                                    }]
                             }
                         }
                     ];
                 },
                 buildTextPayloads: (text) => {
-                    if (isGeminiLiveTranslateModel(this.modelId)) {
-                        throw new UnsupportedFeatureError('Model "vertex/gemini-3.5-live-translate-preview" only supports audio input.');
+                    if (isGeminiLiveTranslateModel(this.modelId) || isVertexLiveTranscribeModel(this.modelId)) {
+                        throw new UnsupportedFeatureError(`Model "vertex/${this.modelId}" only supports audio input.`);
                     }
                     return [
                         {
@@ -1993,26 +2199,58 @@ class VertexRealtimeModel {
                         }
                     ];
                 },
-                buildToolResultPayloads: (result) => [
-                    {
-                        toolResponse: {
-                            functionResponses: [
-                                {
-                                    id: result.toolCallId,
-                                    name: result.toolName,
-                                    response: toolResultPayload(result)
-                                }
-                            ]
+                buildInputMutePayloads: (muted) => {
+                    if (!isVertexLiveTranscribeModel(this.modelId) && !isGeminiLiveTranslateModel(this.modelId))
+                        throw new UnsupportedFeatureError("Vertex input muting is only exposed for Live Transcribe and Live Translate.");
+                    if (inputMuted === muted)
+                        return [];
+                    inputMuted = muted;
+                    return muted ? [{ realtimeInput: { audioStreamEnd: true } }] : [];
+                },
+                buildToolResultPayloads: (result) => {
+                    if (isVertexLiveTranscribeModel(this.modelId))
+                        throw new UnsupportedFeatureError("Live Transcribe does not support tool results.");
+                    return [
+                        {
+                            toolResponse: {
+                                functionResponses: [
+                                    {
+                                        id: result.toolCallId,
+                                        name: result.toolName,
+                                        response: toolResultPayload(result)
+                                    }
+                                ]
+                            }
                         }
+                    ];
+                },
+                buildInterruptPayloads: (sessionConfig) => {
+                    if (isGeminiLiveTranslateModel(this.modelId) || isVertexLiveTranscribeModel(this.modelId)) {
+                        throw new UnsupportedFeatureError("This Vertex Live model does not support client-content interruption.");
                     }
-                ],
-                buildUpdatePayloads: (sessionConfig) => {
+                    const inputConfig = sessionConfig.providerOptions?.realtimeInputConfig;
+                    if (inputConfig?.automaticActivityDetection?.disabled !== true) {
+                        throw new UnsupportedFeatureError("Vertex explicit interruption requires providerOptions.realtimeInputConfig.automaticActivityDetection.disabled=true; automatic VAD interrupts on user speech.");
+                    }
+                    return [{ realtimeInput: { activityStart: {} } }, { realtimeInput: { activityEnd: {} } }];
+                },
+                buildUpdatePayloads: (sessionConfig, previousConfig) => {
                     assertVertexRealtimeConfig(sessionConfig, this.modelId);
-                    return [vertexRealtimeSetup(sessionConfig, this.modelId)];
+                    for (const key of new Set([...Object.keys(previousConfig), ...Object.keys(sessionConfig)])) {
+                        if (key !== "instructions" && !Object.is(previousConfig[key], sessionConfig[key])) {
+                            throw new UnsupportedFeatureError(`Vertex Live cannot update "${key}" after connection; reconnect with the new configuration.`);
+                        }
+                    }
+                    if (sessionConfig.instructions === previousConfig.instructions)
+                        return [];
+                    if (typeof sessionConfig.instructions !== "string" || !sessionConfig.instructions.trim()) {
+                        throw new UnsupportedFeatureError("Vertex Live requires non-empty replacement instructions; reconnect to remove instructions.");
+                    }
+                    return [{ clientContent: { turns: [{ role: "system", parts: [{ text: sessionConfig.instructions }] }], turnComplete: false } }];
                 },
                 buildInitialPayloads: (sessionConfig) => {
                     assertVertexRealtimeConfig(sessionConfig, this.modelId);
-                    return [vertexRealtimeSetup(sessionConfig, this.modelId)];
+                    return [vertexRealtimeSetup(sessionConfig, modelResource)];
                 }
             }
         });
@@ -2031,7 +2269,7 @@ export const createVertex = (options = {}) => {
     }
     const location = options.location ?? process.env.VERTEX_LOCATION ?? process.env.GOOGLE_CLOUD_LOCATION ?? "global";
     const apiVersion = options.apiVersion ?? "v1";
-    const apiHost = location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
+    const apiHost = vertexApiHost(location);
     const configuredBaseURL = options.baseURL ??
         (auth.type === "api-key"
             ? `https://aiplatform.googleapis.com/${apiVersion}`
@@ -2048,14 +2286,23 @@ export const createVertex = (options = {}) => {
             : `https://${veoLocation}-aiplatform.googleapis.com/${apiVersion}/projects/${projectId}/locations/${veoLocation}`);
     const rawFetch = options.fetch ?? globalThis.fetch;
     const fetcher = createVertexAuthenticatedFetch(rawFetch, auth);
+    const interactions = createVertexInteractionsClient(baseURL, fetcher, () => {
+        if (auth.type !== "bearer" || !/\/projects\/[^/]+\/locations\/[^/]+$/.test(baseURL))
+            throw new ConfigurationError("Vertex Interactions requires Google Cloud bearer credentials and a project-scoped endpoint.");
+    });
     const assertModelLocation = (modelId) => {
+        if (modelId.replace(/^publishers\/google\/models\//, "").startsWith("virtual-try-on-"))
+            throw new UnsupportedFeatureError("Virtual Try-On requires vertex.virtualTryOn.generate() with person and product images.");
         if (modelId.startsWith("claude-")) {
             throw new UnsupportedFeatureError("Claude on Vertex is available through languageModel(); this Google-specific surface is not supported.");
         }
+        if (isVertexChatModel(modelId) || /^(?:intfloat\/|publishers\/(?!google\/)|anthropic\/)/.test(modelId)) {
+            throw new UnsupportedFeatureError(`Vertex model "${modelId}" cannot use this Google-specific surface; select its publisher API.`);
+        }
         if (options.baseURL || auth.type !== "bearer") {
             return;
         }
-        const supportedLocations = modelId === "gemini-3.7-flash" || modelId === "gemini-3.6-flash"
+        const supportedLocations = modelId === "gemini-3.7-flash" || modelId === "gemini-3.6-flash" || modelId === "gemini-3.5-transcribe-preview" || isVertexLiveTranscribeModel(modelId) || isGeminiLiveTranslateModel(modelId)
             ? ["global"]
             : modelId === "gemini-3.8-flash" || modelId === "gemini-3.5-flash-lite"
                 ? ["global", "us", "eu"]
@@ -2069,7 +2316,23 @@ export const createVertex = (options = {}) => {
         assertModelLocation(modelId);
         return modelId;
     };
+    const chatModel = (modelId, chatOptions) => {
+        if (auth.type !== "bearer")
+            throw new ConfigurationError("Vertex partner chat requires Google Cloud bearer credentials.");
+        return createVertexChatModel(modelId, baseURL, fetcher, chatOptions);
+    };
+    const assertLanguageSurface = (modelId) => {
+        if (isVertexLiveTranscribeModel(modelId) || isGeminiLiveTranslateModel(modelId)) {
+            throw new UnsupportedFeatureError(`Vertex model "${modelId}" requires realtimeModel(), not a language model factory.`);
+        }
+        if (modelId === "gemini-3.5-transcribe-preview") {
+            throw new UnsupportedFeatureError(`Vertex model "${modelId}" requires transcriptionModel(), not a language model factory.`);
+        }
+    };
     const languageModel = (modelId) => {
+        assertLanguageSurface(modelId);
+        if (isVertexChatModel(modelId))
+            return chatModel(modelId);
         if (modelId.startsWith("claude-")) {
             const encodedId = encodeVertexPathSegment(modelId, "Vertex Claude model ID");
             if (auth.type !== "bearer") {
@@ -2081,6 +2344,7 @@ export const createVertex = (options = {}) => {
         return new VertexLanguageModel(modelId, baseURL, "", fetcher);
     };
     const groundedLanguageModel = (modelId) => {
+        assertLanguageSurface(modelId);
         if (modelId.startsWith("claude-")) {
             throw new UnsupportedFeatureError("Claude on Vertex does not support Google grounded generation; use languageModel().");
         }
@@ -2089,13 +2353,107 @@ export const createVertex = (options = {}) => {
     };
     return createProviderAdapter({
         name: "vertex",
+        endpoints: { ...createVertexEndpointsClient(fetcher, (endpoint, action) => {
+                if (!/^(?:projects\/[^/]+\/locations\/[^/]+\/)?endpoints\/[^/]+$/.test(endpoint))
+                    throw new ConfigurationError("Vertex endpoint must use endpoints/<id> or projects/<project>/locations/<location>/endpoints/<id>.");
+                return `${vertexResourceURL(baseURL, endpoint)}:${action}`;
+            }, () => {
+                if (auth.type !== "bearer")
+                    throw new ConfigurationError("Vertex deployed endpoints require Google Cloud bearer credentials.");
+            }, parseJson), ...createVertexGrpcClient(baseURL, (endpoint, allowPublisher) => {
+                const deployed = /^(?:projects\/[^/]+\/locations\/[^/]+\/)?endpoints\/[^/]+$/;
+                const publisher = /^(?:projects\/[^/]+\/locations\/[^/]+\/)?publishers\/[^/]+\/models\/[^/]+$/;
+                if (!deployed.test(endpoint) && !(allowPublisher && publisher.test(endpoint)))
+                    throw new ConfigurationError(allowPublisher
+                        ? "Vertex serverStreamingPredict requires an endpoint or publisher model resource."
+                        : "Vertex gRPC endpoint must be a deployed endpoint resource.");
+                const encoded = new URL(vertexResourceURL(baseURL, endpoint)).pathname.replace(/^\/v1(?:beta1)?\//, "");
+                // gRPC carries a resource name in protobuf, not an escaped HTTP URL path.
+                const resource = decodeURIComponent(encoded);
+                if (!/^projects\/[^/]+\/locations\/[^/]+\//.test(resource) || (!deployed.test(resource) && !(allowPublisher && publisher.test(resource))))
+                    throw new ConfigurationError("Vertex gRPC requires a project-scoped resource.");
+                return resource;
+            }, async (signal) => {
+                if (auth.type !== "bearer")
+                    throw new ConfigurationError("Vertex gRPC requires Google Cloud bearer credentials.");
+                return awaitVertexToken(auth.getAccessToken, signal);
+            }) },
+        virtualTryOn: createVertexVirtualTryOnClient(new VertexPredictionModel("virtual-try-on-001", baseURL, "", fetcher), () => {
+            if (auth.type !== "bearer")
+                throw new ConfigurationError("Virtual Try-On requires Google Cloud bearer credentials.");
+        }, sanitizeMediaResponse),
+        interactions,
+        claude: createVertexClaudeClient(baseURL, fetcher, () => {
+            if (auth.type !== "bearer")
+                throw new ConfigurationError("Vertex Claude token counting requires Google Cloud bearer credentials.");
+            if (!options.baseURL && !["global", "us", "eu", "asia-southeast1"].includes(location))
+                throw new ConfigurationError("Vertex Claude token counting requires global, us, eu or asia-southeast1.");
+        }),
+        ...createVertexSpecializedClients(baseURL, fetcher, () => {
+            if (auth.type !== "bearer")
+                throw new ConfigurationError("Vertex OCR and FIM require Google Cloud bearer credentials.");
+        }),
         languageModel,
-        embeddingModel: (modelId) => new VertexEmbeddingModel(googleModelId(modelId), baseURL, "", fetcher),
-        transcriptionModel: (modelId) => new VertexTranscriptionModel(googleModelId(modelId), baseURL, "", fetcher),
+        chatModel,
+        responsesModel: (modelId) => {
+            if (auth.type !== "bearer")
+                throw new ConfigurationError("Vertex Grok Responses requires Google Cloud bearer credentials.");
+            return createVertexResponsesModel(modelId, baseURL, fetcher, options.allowUnsafeEndpoints);
+        },
+        gemini: {
+            async countTokens(input) {
+                const modelId = googleModelId(input.modelId.replace(/^publishers\/google\/models\//, ""));
+                if (!/^gemini-[a-z0-9@.-]+$/.test(modelId))
+                    throw new ConfigurationError("Vertex Gemini token counting requires a Gemini model ID.");
+                const body = JSON.stringify({ contents: mapMessages(input.messages),
+                    systemInstruction: input.system !== undefined ? { parts: [{ text: input.system }] } : systemInstruction(input.messages),
+                    tools: input.tools ? mapTools(toToolSet(input.tools)) : undefined,
+                    generationConfig: input.generationConfig });
+                const { signal, cleanup } = withTimeoutSignal(input);
+                try {
+                    const json = await withRetry(() => fetcher(`${baseURL}/publishers/google/models/${encodeVertexPathSegment(modelId, "Vertex model ID")}:countTokens`, {
+                        method: "POST", headers: { "content-type": "application/json" }, body, signal, redirect: "error"
+                    }).then(parseJson), { ...input, abortSignal: signal });
+                    if (!Number.isSafeInteger(json.totalTokens) || json.totalTokens < 0)
+                        throw new ConfigurationError("Vertex returned invalid token count.");
+                    if (json.totalBillableCharacters !== undefined && (!Number.isSafeInteger(json.totalBillableCharacters) || json.totalBillableCharacters < 0))
+                        throw new ConfigurationError("Vertex returned invalid billable character count.");
+                    return { inputTokens: json.totalTokens, ...(json.totalBillableCharacters !== undefined ? { totalBillableCharacters: json.totalBillableCharacters } : {}), rawResponse: json };
+                }
+                finally {
+                    cleanup();
+                }
+            }
+        },
+        multimodalEmbeddings: { embed: (input) => new VertexLegacyMultimodalEmbeddingModel(baseURL, fetcher, () => {
+                if (auth.type !== "bearer")
+                    throw new ConfigurationError("Vertex legacy multimodal embeddings require Google Cloud bearer credentials.");
+            }).embedMultimodal(input) },
+        embeddingModel: (modelId) => {
+            if (modelId.replace(/^publishers\/google\/models\//, "") === "multimodalembedding@001")
+                return new VertexLegacyMultimodalEmbeddingModel(baseURL, fetcher, () => {
+                    if (auth.type !== "bearer")
+                        throw new ConfigurationError("Vertex legacy multimodal embeddings require Google Cloud bearer credentials.");
+                });
+            const openModel = modelId.replace(/^publishers\/intfloat\/models\//, "intfloat/");
+            if (openModel.startsWith("intfloat/")) {
+                if (!/^intfloat\/multilingual-e5-(?:small|large-instruct)-maas$/.test(openModel))
+                    throw new ConfigurationError(`Unsupported Vertex E5 embedding model "${modelId}".`);
+                if (auth.type !== "bearer")
+                    throw new ConfigurationError("Vertex E5 embeddings require Google Cloud bearer credentials.");
+                return new VertexOpenEmbeddingModel(openModel, baseURL, fetcher);
+            }
+            return new VertexEmbeddingModel(googleModelId(modelId), baseURL, fetcher);
+        },
+        transcriptionModel: (modelId) => {
+            if (modelId === "gemini-3.5-transcribe-live-preview")
+                throw new UnsupportedFeatureError("The Live transcription model requires a dedicated realtime session, not transcriptionModel().");
+            return new VertexTranscriptionModel(googleModelId(modelId), baseURL, "", fetcher);
+        },
         speechModel: (modelId) => new VertexSpeechModel(googleModelId(modelId), baseURL, "", fetcher),
         imageGenerationModel: (modelId) => new VertexImageGenerationModel(googleModelId(modelId), baseURL, "", fetcher),
-        videoGenerationModel: (modelId) => new VertexVideoGenerationModel(googleModelId(modelId), isVeoModel(modelId) ? veoBaseURL : baseURL, "", fetcher),
-        musicGenerationModel: (modelId) => new VertexMusicGenerationModel(googleModelId(modelId), baseURL, "", fetcher),
+        videoGenerationModel: (modelId) => new VertexVideoGenerationModel(googleModelId(modelId), isVeoModel(modelId) ? veoBaseURL : baseURL, "", fetcher, interactions),
+        musicGenerationModel: (modelId) => new VertexMusicGenerationModel(googleModelId(modelId), baseURL, "", fetcher, interactions),
         realtimeModel: (modelId) => new VertexRealtimeModel(googleModelId(modelId), auth, location, apiVersion, options.realtimeConnectionFactory, options.realtimeURL
             ? assertTrustedEndpoint(options.realtimeURL, {
                 label: "Vertex realtimeURL",
@@ -2103,10 +2461,13 @@ export const createVertex = (options = {}) => {
                 allowedHosts: [apiHost],
                 allowUnsafe: options.allowUnsafeEndpoints
             }).toString()
-            : undefined, options.allowUnsafeEndpoints),
+            : undefined, options.allowUnsafeEndpoints, baseURL.match(/\/(projects\/[^/]+\/locations\/[^/]+)(?:\/|$)/)?.[1] ?? (projectId ? `projects/${projectId}/locations/${location}` : undefined)),
         groundedLanguageModel,
         caches: new VertexContextCachesClient(baseURL, "", fetcher, assertModelLocation),
-        batches: new VertexBatchesClient(baseURL, "", fetcher, assertModelLocation),
+        batches: new VertexBatchesClient(baseURL, fetcher, () => {
+            if (auth.type !== "bearer")
+                throw new ConfigurationError("Vertex batch jobs require Google Cloud bearer credentials and a project-scoped endpoint.");
+        }),
         predictionModel: (modelId) => {
             const resource = vertexPublisherResource(modelId);
             if (modelId.startsWith("claude-")) {