@ai-sdk/gateway 4.0.0-beta.10 → 4.0.0-beta.109

package/dist/index.js

@@ -1,46 +1,73 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name8 in all)
-    __defProp(target, name8, { get: all[name8], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+// src/gateway-realtime-auth.ts
+var GATEWAY_REALTIME_SUBPROTOCOL = "ai-gateway-realtime.v1";
+var GATEWAY_AUTH_SUBPROTOCOL_PREFIX = "ai-gateway-auth.";
+var GATEWAY_TEAM_SUBPROTOCOL_PREFIX = "ai-gateway-team.";
+function getGatewayRealtimeProtocols(token, options) {
+  const protocols = [
+    GATEWAY_REALTIME_SUBPROTOCOL,
+    `${GATEWAY_AUTH_SUBPROTOCOL_PREFIX}${token}`
+  ];
+  if (options == null ? void 0 : options.teamIdOrSlug) {
+    protocols.push(
+      `${GATEWAY_TEAM_SUBPROTOCOL_PREFIX}${encodeSubprotocolValue(options.teamIdOrSlug)}`
+    );
   }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  GatewayAuthenticationError: () => GatewayAuthenticationError,
-  GatewayError: () => GatewayError,
-  GatewayInternalServerError: () => GatewayInternalServerError,
-  GatewayInvalidRequestError: () => GatewayInvalidRequestError,
-  GatewayModelNotFoundError: () => GatewayModelNotFoundError,
-  GatewayRateLimitError: () => GatewayRateLimitError,
-  GatewayResponseError: () => GatewayResponseError,
-  createGateway: () => createGatewayProvider,
-  createGatewayProvider: () => createGatewayProvider,
-  gateway: () => gateway
-});
-module.exports = __toCommonJS(src_exports);
+  return protocols;
+}
+function getGatewayRealtimeAuthToken(secWebSocketProtocol) {
+  var _a11;
+  return ((_a11 = findProtocol(secWebSocketProtocol, GATEWAY_AUTH_SUBPROTOCOL_PREFIX)) == null ? void 0 : _a11.slice(
+    GATEWAY_AUTH_SUBPROTOCOL_PREFIX.length
+  )) || void 0;
+}
+function getGatewayRealtimeTeamIdOrSlug(secWebSocketProtocol) {
+  var _a11;
+  const encoded = (_a11 = findProtocol(
+    secWebSocketProtocol,
+    GATEWAY_TEAM_SUBPROTOCOL_PREFIX
+  )) == null ? void 0 : _a11.slice(GATEWAY_TEAM_SUBPROTOCOL_PREFIX.length);
+  if (!encoded) return void 0;
+  try {
+    return decodeSubprotocolValue(encoded) || void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function findProtocol(secWebSocketProtocol, prefix) {
+  return secWebSocketProtocol == null ? void 0 : secWebSocketProtocol.split(",").map((protocol) => protocol.trim()).find((protocol) => protocol.startsWith(prefix));
+}
+function encodeSubprotocolValue(value) {
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/u, "");
+}
+function decodeSubprotocolValue(value) {
+  const base64 = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = "=".repeat((4 - base64.length % 4) % 4);
+  const binary = atob(`${base64}${padding}`);
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
 
 // src/gateway-provider.ts
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
+import {
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler11,
+  createJsonResponseHandler as createJsonResponseHandler10,
+  loadOptionalSetting,
+  postJsonToApi as postJsonToApi8,
+  withoutTrailingSlash,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
+import { z as z16 } from "zod/v4";
 
 // src/errors/as-gateway-error.ts
-var import_provider = require("@ai-sdk/provider");
+import { APICallError } from "@ai-sdk/provider";
 
 // src/errors/create-gateway-error.ts
-var import_v42 = require("zod/v4");
+import { z as z2 } from "zod/v4";
 
 // src/errors/gateway-error.ts
 var marker = "vercel.ai.gateway.error";
@@ -51,13 +78,19 @@ var GatewayError = class _GatewayError extends (_b = Error, _a = symbol, _b) {
     message,
     statusCode = 500,
     cause,
-    generationId
+    generationId,
+    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
+    statusCode === 409 || // conflict
+    statusCode === 429 || // too many requests
+    statusCode >= 500)
+    // server error
   }) {
     super(generationId ? `${message} [${generationId}]` : message);
     this[_a] = true;
     this.statusCode = statusCode;
     this.cause = cause;
     this.generationId = generationId;
+    this.isRetryable = isRetryable;
   }
   /**
    * Checks if the given error is a Gateway Error.
@@ -99,24 +132,24 @@ var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b2
   static createContextualError({
     apiKeyProvided,
     oidcTokenProvided,
-    message = "Authentication failed",
     statusCode = 401,
     cause,
     generationId
   }) {
     let contextualMessage;
     if (apiKeyProvided) {
-      contextualMessage = `AI Gateway authentication failed: Invalid API key.
+      contextualMessage = `AI Gateway authentication failed: Invalid API key or token.
 
 Create a new API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys
 
-Provide via 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.`;
+Provide an API key or Vercel access token via 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.`;
     } else if (oidcTokenProvided) {
       contextualMessage = `AI Gateway authentication failed: Invalid OIDC token.
 
 Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the token.
 
-Alternatively, use an API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys`;
+Alternatively, use an API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys
+or pass a Vercel access token via the 'apiKey' option.`;
     } else {
       contextualMessage = `AI Gateway authentication failed: No authentication provided.
 
@@ -124,7 +157,10 @@ Option 1 - API key:
 Create an API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys
 Provide via 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.
 
-Option 2 - OIDC token:
+Option 2 - Vercel access token:
+Pass a Vercel personal access token or Vercel app access token via the 'apiKey' option.
+
+Option 3 - OIDC token:
 Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the token.`;
     }
     return new _GatewayAuthenticationError({
@@ -183,15 +219,15 @@ var GatewayRateLimitError = class extends (_b4 = GatewayError, _a4 = symbol4, _b
 };
 
 // src/errors/gateway-model-not-found-error.ts
-var import_v4 = require("zod/v4");
-var import_provider_utils = require("@ai-sdk/provider-utils");
+import { z } from "zod/v4";
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
 var name4 = "GatewayModelNotFoundError";
 var marker5 = `vercel.ai.gateway.error.${name4}`;
 var symbol5 = Symbol.for(marker5);
-var modelNotFoundParamSchema = (0, import_provider_utils.lazySchema)(
-  () => (0, import_provider_utils.zodSchema)(
-    import_v4.z.object({
-      modelId: import_v4.z.string()
+var modelNotFoundParamSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      modelId: z.string()
     })
   )
 );
@@ -239,12 +275,58 @@ var GatewayInternalServerError = class extends (_b6 = GatewayError, _a6 = symbol
   }
 };
 
-// src/errors/gateway-response-error.ts
-var name6 = "GatewayResponseError";
+// src/errors/gateway-failed-dependency-error.ts
+var name6 = "GatewayFailedDependencyError";
 var marker7 = `vercel.ai.gateway.error.${name6}`;
 var symbol7 = Symbol.for(marker7);
 var _a7, _b7;
-var GatewayResponseError = class extends (_b7 = GatewayError, _a7 = symbol7, _b7) {
+var GatewayFailedDependencyError = class extends (_b7 = GatewayError, _a7 = symbol7, _b7) {
+  constructor({
+    message = "Failed dependency",
+    statusCode = 424,
+    cause,
+    generationId
+  } = {}) {
+    super({ message, statusCode, cause, generationId });
+    this[_a7] = true;
+    // used in isInstance
+    this.name = name6;
+    this.type = "failed_dependency";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol7 in error;
+  }
+};
+
+// src/errors/gateway-forbidden-error.ts
+var name7 = "GatewayForbiddenError";
+var marker8 = `vercel.ai.gateway.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8, _b8;
+var GatewayForbiddenError = class extends (_b8 = GatewayError, _a8 = symbol8, _b8) {
+  constructor({
+    message = "Forbidden",
+    statusCode = 403,
+    cause,
+    generationId
+  } = {}) {
+    super({ message, statusCode, cause, generationId });
+    this[_a8] = true;
+    // used in isInstance
+    this.name = name7;
+    this.type = "forbidden";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol8 in error;
+  }
+};
+
+// src/errors/gateway-response-error.ts
+var name8 = "GatewayResponseError";
+var marker9 = `vercel.ai.gateway.error.${name8}`;
+var symbol9 = Symbol.for(marker9);
+var _a9, _b9;
+var GatewayResponseError = class extends (_b9 = GatewayError, _a9 = symbol9, _b9) {
   constructor({
     message = "Invalid response from Gateway",
     statusCode = 502,
@@ -254,20 +336,24 @@ var GatewayResponseError = class extends (_b7 = GatewayError, _a7 = symbol7, _b7
     generationId
   } = {}) {
     super({ message, statusCode, cause, generationId });
-    this[_a7] = true;
+    this[_a9] = true;
     // used in isInstance
-    this.name = name6;
+    this.name = name8;
     this.type = "response_error";
     this.response = response;
     this.validationError = validationError;
   }
   static isInstance(error) {
-    return GatewayError.hasMarker(error) && symbol7 in error;
+    return GatewayError.hasMarker(error) && symbol9 in error;
   }
 };
 
 // src/errors/create-gateway-error.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
+import {
+  lazySchema as lazySchema2,
+  safeValidateTypes,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
 async function createGatewayErrorFromResponse({
   response,
   statusCode,
@@ -275,8 +361,8 @@ async function createGatewayErrorFromResponse({
   cause,
   authMethod
 }) {
-  var _a9;
-  const parseResult = await (0, import_provider_utils2.safeValidateTypes)({
+  var _a11;
+  const parseResult = await safeValidateTypes({
     value: response,
     schema: gatewayErrorResponseSchema
   });
@@ -294,7 +380,7 @@ async function createGatewayErrorFromResponse({
   const validatedResponse = parseResult.value;
   const errorType = validatedResponse.error.type;
   const message = validatedResponse.error.message;
-  const generationId = (_a9 = validatedResponse.generationId) != null ? _a9 : void 0;
+  const generationId = (_a11 = validatedResponse.generationId) != null ? _a11 : void 0;
   switch (errorType) {
     case "authentication_error":
       return GatewayAuthenticationError.createContextualError({
@@ -319,7 +405,7 @@ async function createGatewayErrorFromResponse({
         generationId
       });
     case "model_not_found": {
-      const modelResult = await (0, import_provider_utils2.safeValidateTypes)({
+      const modelResult = await safeValidateTypes({
         value: validatedResponse.error.param,
         schema: modelNotFoundParamSchema
       });
@@ -338,6 +424,20 @@ async function createGatewayErrorFromResponse({
         cause,
         generationId
       });
+    case "failed_dependency":
+      return new GatewayFailedDependencyError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
+    case "forbidden":
+      return new GatewayForbiddenError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
     default:
       return new GatewayInternalServerError({
         message,
@@ -347,26 +447,41 @@ async function createGatewayErrorFromResponse({
       });
   }
 }
-var gatewayErrorResponseSchema = (0, import_provider_utils2.lazySchema)(
-  () => (0, import_provider_utils2.zodSchema)(
-    import_v42.z.object({
-      error: import_v42.z.object({
-        message: import_v42.z.string(),
-        type: import_v42.z.string().nullish(),
-        param: import_v42.z.unknown().nullish(),
-        code: import_v42.z.union([import_v42.z.string(), import_v42.z.number()]).nullish()
+var gatewayErrorResponseSchema = lazySchema2(
+  () => zodSchema2(
+    z2.object({
+      error: z2.object({
+        message: z2.string(),
+        type: z2.string().nullish(),
+        param: z2.unknown().nullish(),
+        code: z2.union([z2.string(), z2.number()]).nullish()
       }),
-      generationId: import_v42.z.string().nullish()
+      generationId: z2.string().nullish()
     })
   )
 );
 
+// src/errors/extract-api-call-response.ts
+function extractApiCallResponse(error) {
+  if (error.data !== void 0) {
+    return error.data;
+  }
+  if (error.responseBody != null) {
+    try {
+      return JSON.parse(error.responseBody);
+    } catch (e) {
+      return error.responseBody;
+    }
+  }
+  return {};
+}
+
 // src/errors/gateway-timeout-error.ts
-var name7 = "GatewayTimeoutError";
-var marker8 = `vercel.ai.gateway.error.${name7}`;
-var symbol8 = Symbol.for(marker8);
-var _a8, _b8;
-var GatewayTimeoutError = class _GatewayTimeoutError extends (_b8 = GatewayError, _a8 = symbol8, _b8) {
+var name9 = "GatewayTimeoutError";
+var marker10 = `vercel.ai.gateway.error.${name9}`;
+var symbol10 = Symbol.for(marker10);
+var _a10, _b10;
+var GatewayTimeoutError = class _GatewayTimeoutError extends (_b10 = GatewayError, _a10 = symbol10, _b10) {
   constructor({
     message = "Request timed out",
     statusCode = 408,
@@ -374,13 +489,13 @@ var GatewayTimeoutError = class _GatewayTimeoutError extends (_b8 = GatewayError
     generationId
   } = {}) {
     super({ message, statusCode, cause, generationId });
-    this[_a8] = true;
+    this[_a10] = true;
     // used in isInstance
-    this.name = name7;
+    this.name = name9;
     this.type = "timeout_error";
   }
   static isInstance(error) {
-    return GatewayError.hasMarker(error) && symbol8 in error;
+    return GatewayError.hasMarker(error) && symbol10 in error;
   }
   /**
    * Creates a helpful timeout error message with troubleshooting guidance
@@ -420,7 +535,7 @@ function isTimeoutError(error) {
   return false;
 }
 async function asGatewayError(error, authMethod) {
-  var _a9;
+  var _a11;
   if (GatewayError.isInstance(error)) {
     return error;
   }
@@ -430,7 +545,7 @@ async function asGatewayError(error, authMethod) {
       cause: error
     });
   }
-  if (import_provider.APICallError.isInstance(error)) {
+  if (APICallError.isInstance(error)) {
     if (error.cause && isTimeoutError(error.cause)) {
       return GatewayTimeoutError.createTimeoutError({
         originalMessage: error.message,
@@ -439,7 +554,7 @@ async function asGatewayError(error, authMethod) {
     }
     return await createGatewayErrorFromResponse({
       response: extractApiCallResponse(error),
-      statusCode: (_a9 = error.statusCode) != null ? _a9 : 500,
+      statusCode: (_a11 = error.statusCode) != null ? _a11 : 500,
       defaultMessage: "Gateway request failed",
       cause: error,
       authMethod
@@ -454,53 +569,65 @@ async function asGatewayError(error, authMethod) {
   });
 }
 
-// src/errors/extract-api-call-response.ts
-function extractApiCallResponse(error) {
-  if (error.data !== void 0) {
-    return error.data;
-  }
-  if (error.responseBody != null) {
-    try {
-      return JSON.parse(error.responseBody);
-    } catch (e) {
-      return error.responseBody;
-    }
-  }
-  return {};
-}
+// src/gateway-headers.ts
+var GATEWAY_AUTH_METHOD_HEADER = "ai-gateway-auth-method";
+var VERCEL_AI_GATEWAY_TEAM_HEADER = "x-vercel-ai-gateway-team";
 
 // src/errors/parse-auth-method.ts
-var import_v43 = require("zod/v4");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var GATEWAY_AUTH_METHOD_HEADER = "ai-gateway-auth-method";
+import { z as z3 } from "zod/v4";
+import {
+  lazySchema as lazySchema3,
+  safeValidateTypes as safeValidateTypes2,
+  zodSchema as zodSchema3
+} from "@ai-sdk/provider-utils";
 async function parseAuthMethod(headers) {
-  const result = await (0, import_provider_utils3.safeValidateTypes)({
+  const result = await safeValidateTypes2({
     value: headers[GATEWAY_AUTH_METHOD_HEADER],
     schema: gatewayAuthMethodSchema
   });
   return result.success ? result.value : void 0;
 }
-var gatewayAuthMethodSchema = (0, import_provider_utils3.lazySchema)(
-  () => (0, import_provider_utils3.zodSchema)(import_v43.z.union([import_v43.z.literal("api-key"), import_v43.z.literal("oidc")]))
+var gatewayAuthMethodSchema = lazySchema3(
+  () => zodSchema3(z3.union([z3.literal("api-key"), z3.literal("oidc")]))
 );
 
 // src/gateway-fetch-metadata.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v44 = require("zod/v4");
+import {
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  getFromApi,
+  lazySchema as lazySchema4,
+  resolve,
+  zodSchema as zodSchema4
+} from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod/v4";
+
+// src/gateway-model-entry.ts
+var KNOWN_MODEL_TYPES = [
+  "embedding",
+  "image",
+  "language",
+  "reranking",
+  "speech",
+  "transcription",
+  "video"
+];
+
+// src/gateway-fetch-metadata.ts
 var GatewayFetchMetadata = class {
   constructor(config) {
     this.config = config;
   }
   async getAvailableModels() {
     try {
-      const { value } = await (0, import_provider_utils4.getFromApi)({
+      const { value } = await getFromApi({
         url: `${this.config.baseURL}/config`,
-        headers: await (0, import_provider_utils4.resolve)(this.config.headers()),
-        successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+        headers: this.config.headers ? await resolve(this.config.headers) : void 0,
+        successfulResponseHandler: createJsonResponseHandler(
           gatewayAvailableModelsResponseSchema
         ),
-        failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
-          errorSchema: import_v44.z.any(),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z4.any(),
           errorToMessage: (data) => data
         }),
         fetch: this.config.fetch
@@ -513,14 +640,14 @@ var GatewayFetchMetadata = class {
   async getCredits() {
     try {
       const baseUrl = new URL(this.config.baseURL);
-      const { value } = await (0, import_provider_utils4.getFromApi)({
+      const { value } = await getFromApi({
         url: `${baseUrl.origin}/v1/credits`,
-        headers: await (0, import_provider_utils4.resolve)(this.config.headers()),
-        successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+        headers: this.config.headers ? await resolve(this.config.headers) : void 0,
+        successfulResponseHandler: createJsonResponseHandler(
           gatewayCreditsResponseSchema
         ),
-        failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
-          errorSchema: import_v44.z.any(),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z4.any(),
           errorToMessage: (data) => data
         }),
         fetch: this.config.fetch
@@ -531,19 +658,19 @@ var GatewayFetchMetadata = class {
     }
   }
 };
-var gatewayAvailableModelsResponseSchema = (0, import_provider_utils4.lazySchema)(
-  () => (0, import_provider_utils4.zodSchema)(
-    import_v44.z.object({
-      models: import_v44.z.array(
-        import_v44.z.object({
-          id: import_v44.z.string(),
-          name: import_v44.z.string(),
-          description: import_v44.z.string().nullish(),
-          pricing: import_v44.z.object({
-            input: import_v44.z.string(),
-            output: import_v44.z.string(),
-            input_cache_read: import_v44.z.string().nullish(),
-            input_cache_write: import_v44.z.string().nullish()
+var gatewayAvailableModelsResponseSchema = lazySchema4(
+  () => zodSchema4(
+    z4.object({
+      models: z4.array(
+        z4.object({
+          id: z4.string(),
+          name: z4.string(),
+          description: z4.string().nullish(),
+          pricing: z4.object({
+            input: z4.string(),
+            output: z4.string(),
+            input_cache_read: z4.string().nullish(),
+            input_cache_write: z4.string().nullish()
           }).transform(
             ({ input, output, input_cache_read, input_cache_write }) => ({
               input,
@@ -552,22 +679,26 @@ var gatewayAvailableModelsResponseSchema = (0, import_provider_utils4.lazySchema
               ...input_cache_write ? { cacheCreationInputTokens: input_cache_write } : {}
             })
           ).nullish(),
-          specification: import_v44.z.object({
-            specificationVersion: import_v44.z.literal("v3"),
-            provider: import_v44.z.string(),
-            modelId: import_v44.z.string()
+          specification: z4.object({
+            specificationVersion: z4.literal("v4"),
+            provider: z4.string(),
+            modelId: z4.string()
           }),
-          modelType: import_v44.z.enum(["embedding", "image", "language", "video"]).nullish()
+          modelType: z4.string().nullish()
         })
+      ).transform(
+        (models) => models.filter(
+          (m) => m.modelType == null || KNOWN_MODEL_TYPES.includes(m.modelType)
+        )
       )
     })
   )
 );
-var gatewayCreditsResponseSchema = (0, import_provider_utils4.lazySchema)(
-  () => (0, import_provider_utils4.zodSchema)(
-    import_v44.z.object({
-      balance: import_v44.z.string(),
-      total_used: import_v44.z.string()
+var gatewayCreditsResponseSchema = lazySchema4(
+  () => zodSchema4(
+    z4.object({
+      balance: z4.string(),
+      total_used: z4.string()
     }).transform(({ balance, total_used }) => ({
       balance,
       totalUsed: total_used
@@ -575,16 +706,238 @@ var gatewayCreditsResponseSchema = (0, import_provider_utils4.lazySchema)(
   )
 );
 
+// src/gateway-spend-report.ts
+import {
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  getFromApi as getFromApi2,
+  lazySchema as lazySchema5,
+  resolve as resolve2,
+  zodSchema as zodSchema5
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
+var GatewaySpendReport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async getSpendReport(params) {
+    try {
+      const baseUrl = new URL(this.config.baseURL);
+      const searchParams = new URLSearchParams();
+      searchParams.set("start_date", params.startDate);
+      searchParams.set("end_date", params.endDate);
+      if (params.groupBy) {
+        searchParams.set("group_by", params.groupBy);
+      }
+      if (params.datePart) {
+        searchParams.set("date_part", params.datePart);
+      }
+      if (params.userId) {
+        searchParams.set("user_id", params.userId);
+      }
+      if (params.model) {
+        searchParams.set("model", params.model);
+      }
+      if (params.provider) {
+        searchParams.set("provider", params.provider);
+      }
+      if (params.credentialType) {
+        searchParams.set("credential_type", params.credentialType);
+      }
+      if (params.tags && params.tags.length > 0) {
+        searchParams.set("tags", params.tags.join(","));
+      }
+      const { value } = await getFromApi2({
+        url: `${baseUrl.origin}/v1/report?${searchParams.toString()}`,
+        headers: this.config.headers ? await resolve2(this.config.headers) : void 0,
+        successfulResponseHandler: createJsonResponseHandler2(
+          gatewaySpendReportResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler2({
+          errorSchema: z5.any(),
+          errorToMessage: (data) => data
+        }),
+        fetch: this.config.fetch
+      });
+      return value;
+    } catch (error) {
+      throw await asGatewayError(error);
+    }
+  }
+};
+var gatewaySpendReportResponseSchema = lazySchema5(
+  () => zodSchema5(
+    z5.object({
+      results: z5.array(
+        z5.object({
+          day: z5.string().optional(),
+          hour: z5.string().optional(),
+          user: z5.string().optional(),
+          model: z5.string().optional(),
+          tag: z5.string().optional(),
+          provider: z5.string().optional(),
+          credential_type: z5.enum(["byok", "system"]).optional(),
+          total_cost: z5.number(),
+          market_cost: z5.number().optional(),
+          input_tokens: z5.number().optional(),
+          output_tokens: z5.number().optional(),
+          cached_input_tokens: z5.number().optional(),
+          cache_creation_input_tokens: z5.number().optional(),
+          reasoning_tokens: z5.number().optional(),
+          request_count: z5.number().optional()
+        }).transform(
+          ({
+            credential_type,
+            total_cost,
+            market_cost,
+            input_tokens,
+            output_tokens,
+            cached_input_tokens,
+            cache_creation_input_tokens,
+            reasoning_tokens,
+            request_count,
+            ...rest
+          }) => ({
+            ...rest,
+            ...credential_type !== void 0 ? { credentialType: credential_type } : {},
+            totalCost: total_cost,
+            ...market_cost !== void 0 ? { marketCost: market_cost } : {},
+            ...input_tokens !== void 0 ? { inputTokens: input_tokens } : {},
+            ...output_tokens !== void 0 ? { outputTokens: output_tokens } : {},
+            ...cached_input_tokens !== void 0 ? { cachedInputTokens: cached_input_tokens } : {},
+            ...cache_creation_input_tokens !== void 0 ? { cacheCreationInputTokens: cache_creation_input_tokens } : {},
+            ...reasoning_tokens !== void 0 ? { reasoningTokens: reasoning_tokens } : {},
+            ...request_count !== void 0 ? { requestCount: request_count } : {}
+          })
+        )
+      )
+    })
+  )
+);
+
+// src/gateway-generation-info.ts
+import {
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  getFromApi as getFromApi3,
+  lazySchema as lazySchema6,
+  resolve as resolve3,
+  zodSchema as zodSchema6
+} from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var GatewayGenerationInfoFetcher = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async getGenerationInfo(params) {
+    try {
+      const baseUrl = new URL(this.config.baseURL);
+      const { value } = await getFromApi3({
+        url: `${baseUrl.origin}/v1/generation?id=${encodeURIComponent(params.id)}`,
+        headers: this.config.headers ? await resolve3(this.config.headers) : void 0,
+        successfulResponseHandler: createJsonResponseHandler3(
+          gatewayGenerationInfoResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler3({
+          errorSchema: z6.any(),
+          errorToMessage: (data) => data
+        }),
+        fetch: this.config.fetch
+      });
+      return value;
+    } catch (error) {
+      throw await asGatewayError(error);
+    }
+  }
+};
+var gatewayGenerationInfoResponseSchema = lazySchema6(
+  () => zodSchema6(
+    z6.object({
+      data: z6.object({
+        id: z6.string(),
+        total_cost: z6.number(),
+        upstream_inference_cost: z6.number(),
+        usage: z6.number(),
+        created_at: z6.string(),
+        model: z6.string(),
+        is_byok: z6.boolean(),
+        provider_name: z6.string(),
+        streamed: z6.boolean(),
+        finish_reason: z6.string(),
+        latency: z6.number(),
+        generation_time: z6.number(),
+        native_tokens_prompt: z6.number(),
+        native_tokens_completion: z6.number(),
+        native_tokens_reasoning: z6.number(),
+        native_tokens_cached: z6.number(),
+        native_tokens_cache_creation: z6.number(),
+        billable_web_search_calls: z6.number()
+      }).transform(
+        ({
+          total_cost,
+          upstream_inference_cost,
+          created_at,
+          is_byok,
+          provider_name,
+          finish_reason,
+          generation_time,
+          native_tokens_prompt,
+          native_tokens_completion,
+          native_tokens_reasoning,
+          native_tokens_cached,
+          native_tokens_cache_creation,
+          billable_web_search_calls,
+          ...rest
+        }) => ({
+          ...rest,
+          totalCost: total_cost,
+          upstreamInferenceCost: upstream_inference_cost,
+          createdAt: created_at,
+          isByok: is_byok,
+          providerName: provider_name,
+          finishReason: finish_reason,
+          generationTime: generation_time,
+          promptTokens: native_tokens_prompt,
+          completionTokens: native_tokens_completion,
+          reasoningTokens: native_tokens_reasoning,
+          cachedTokens: native_tokens_cached,
+          cacheCreationTokens: native_tokens_cache_creation,
+          billableWebSearchCalls: billable_web_search_calls
+        })
+      )
+    }).transform(({ data }) => data)
+  )
+);
+
 // src/gateway-language-model.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
-var GatewayLanguageModel = class {
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler4,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  postJsonToApi,
+  resolve as resolve4,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
+var GatewayLanguageModel = class _GatewayLanguageModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
     this.supportedUrls = { "*/*": [/.*/] };
   }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _GatewayLanguageModel(options.modelId, options.config);
+  }
   get provider() {
     return this.config.provider;
   }
@@ -598,24 +951,24 @@ var GatewayLanguageModel = class {
   async doGenerate(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await (0, import_provider_utils5.resolve)(this.config.headers());
+    const resolvedHeaders = this.config.headers ? await resolve4(this.config.headers) : void 0;
     try {
       const {
         responseHeaders,
         value: responseBody,
         rawValue: rawResponse
-      } = await (0, import_provider_utils5.postJsonToApi)({
+      } = await postJsonToApi({
         url: this.getUrl(),
-        headers: (0, import_provider_utils5.combineHeaders)(
+        headers: combineHeaders(
           resolvedHeaders,
           options.headers,
           this.getModelConfigHeaders(this.modelId, false),
-          await (0, import_provider_utils5.resolve)(this.config.o11yHeaders)
+          await resolve4(this.config.o11yHeaders)
         ),
         body: args,
-        successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(import_v45.z.any()),
-        failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
-          errorSchema: import_v45.z.any(),
+        successfulResponseHandler: createJsonResponseHandler4(z7.any()),
+        failedResponseHandler: createJsonErrorResponseHandler4({
+          errorSchema: z7.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -628,26 +981,29 @@ var GatewayLanguageModel = class {
         warnings
       };
     } catch (error) {
-      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders != null ? resolvedHeaders : {})
+      );
     }
   }
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await (0, import_provider_utils5.resolve)(this.config.headers());
+    const resolvedHeaders = this.config.headers ? await resolve4(this.config.headers) : void 0;
     try {
-      const { value: response, responseHeaders } = await (0, import_provider_utils5.postJsonToApi)({
+      const { value: response, responseHeaders } = await postJsonToApi({
         url: this.getUrl(),
-        headers: (0, import_provider_utils5.combineHeaders)(
+        headers: combineHeaders(
           resolvedHeaders,
           options.headers,
           this.getModelConfigHeaders(this.modelId, true),
-          await (0, import_provider_utils5.resolve)(this.config.o11yHeaders)
+          await resolve4(this.config.o11yHeaders)
         ),
         body: args,
-        successfulResponseHandler: (0, import_provider_utils5.createEventSourceResponseHandler)(import_v45.z.any()),
-        failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
-          errorSchema: import_v45.z.any(),
+        successfulResponseHandler: createEventSourceResponseHandler(z7.any()),
+        failedResponseHandler: createJsonErrorResponseHandler4({
+          errorSchema: z7.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -683,29 +1039,30 @@ var GatewayLanguageModel = class {
         response: { headers: responseHeaders }
       };
     } catch (error) {
-      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders != null ? resolvedHeaders : {})
+      );
     }
   }
-  isFilePart(part) {
-    return part && typeof part === "object" && "type" in part && part.type === "file";
-  }
   /**
-   * Encodes file parts in the prompt to base64. Mutates the passed options
-   * instance directly to avoid copying the file data.
+   * Encodes inline `Uint8Array` file data to a base64 string in place.
    * @param options - The options to encode.
-   * @returns The options with the file parts encoded.
+   * @returns The options with the file data encoded.
    */
   maybeEncodeFileParts(options) {
     for (const message of options.prompt) {
+      if (!Array.isArray(message.content)) {
+        continue;
+      }
       for (const part of message.content) {
-        if (this.isFilePart(part)) {
-          const filePart = part;
-          if (filePart.data instanceof Uint8Array) {
-            const buffer = Uint8Array.from(filePart.data);
-            const base64Data = Buffer.from(buffer).toString("base64");
-            filePart.data = new URL(
-              `data:${filePart.mediaType || "application/octet-stream"};base64,${base64Data}`
-            );
+        if (part.type === "file" || part.type === "reasoning-file") {
+          part.data = maybeBase64EncodeFileData(part.data);
+        } else if (part.type === "tool-result" && part.output.type === "content") {
+          for (const contentPart of part.output.value) {
+            if (contentPart.type === "file") {
+              contentPart.data = maybeBase64EncodeFileData(contentPart.data);
+            }
           }
         }
       }
@@ -717,24 +1074,53 @@ var GatewayLanguageModel = class {
   }
   getModelConfigHeaders(modelId, streaming) {
     return {
-      "ai-language-model-specification-version": "3",
+      "ai-language-model-specification-version": "4",
       "ai-language-model-id": modelId,
       "ai-language-model-streaming": String(streaming)
     };
   }
 };
+function maybeBase64EncodeFileData(data) {
+  if (data.type === "data") {
+    const bytes = data.data;
+    if (bytes instanceof Uint8Array) {
+      return { ...data, data: Buffer.from(bytes).toString("base64") };
+    }
+  }
+  return data;
+}
 
 // src/gateway-embedding-model.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var import_v46 = require("zod/v4");
-var GatewayEmbeddingModel = class {
+import {
+  combineHeaders as combineHeaders2,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler5,
+  createJsonResponseHandler as createJsonResponseHandler5,
+  lazySchema as lazySchema7,
+  postJsonToApi as postJsonToApi2,
+  resolve as resolve5,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2,
+  zodSchema as zodSchema7
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var GatewayEmbeddingModel = class _GatewayEmbeddingModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
     this.maxEmbeddingsPerCall = 2048;
     this.supportsParallelCalls = true;
   }
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE2](options) {
+    return new _GatewayEmbeddingModel(options.modelId, options.config);
+  }
   get provider() {
     return this.config.provider;
   }
@@ -744,30 +1130,30 @@ var GatewayEmbeddingModel = class {
     abortSignal,
     providerOptions
   }) {
-    var _a9;
-    const resolvedHeaders = await (0, import_provider_utils6.resolve)(this.config.headers());
+    var _a11, _b11;
+    const resolvedHeaders = this.config.headers ? await resolve5(this.config.headers) : void 0;
     try {
       const {
         responseHeaders,
         value: responseBody,
         rawValue
-      } = await (0, import_provider_utils6.postJsonToApi)({
+      } = await postJsonToApi2({
         url: this.getUrl(),
-        headers: (0, import_provider_utils6.combineHeaders)(
+        headers: combineHeaders2(
           resolvedHeaders,
           headers != null ? headers : {},
           this.getModelConfigHeaders(),
-          await (0, import_provider_utils6.resolve)(this.config.o11yHeaders)
+          await resolve5(this.config.o11yHeaders)
         ),
         body: {
           values,
           ...providerOptions ? { providerOptions } : {}
         },
-        successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(
+        successfulResponseHandler: createJsonResponseHandler5(
           gatewayEmbeddingResponseSchema
         ),
-        failedResponseHandler: (0, import_provider_utils6.createJsonErrorResponseHandler)({
-          errorSchema: import_v46.z.any(),
+        failedResponseHandler: createJsonErrorResponseHandler5({
+          errorSchema: z8.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -775,13 +1161,16 @@ var GatewayEmbeddingModel = class {
       });
       return {
         embeddings: responseBody.embeddings,
-        usage: (_a9 = responseBody.usage) != null ? _a9 : void 0,
+        usage: (_a11 = responseBody.usage) != null ? _a11 : void 0,
         providerMetadata: responseBody.providerMetadata,
         response: { headers: responseHeaders, body: rawValue },
-        warnings: []
+        warnings: (_b11 = responseBody.warnings) != null ? _b11 : []
       };
     } catch (error) {
-      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders != null ? resolvedHeaders : {})
+      );
     }
   }
   getUrl() {
@@ -789,32 +1178,73 @@ var GatewayEmbeddingModel = class {
   }
   getModelConfigHeaders() {
     return {
-      "ai-embedding-model-specification-version": "3",
+      "ai-embedding-model-specification-version": "4",
       "ai-model-id": this.modelId
     };
   }
 };
-var gatewayEmbeddingResponseSchema = (0, import_provider_utils6.lazySchema)(
-  () => (0, import_provider_utils6.zodSchema)(
-    import_v46.z.object({
-      embeddings: import_v46.z.array(import_v46.z.array(import_v46.z.number())),
-      usage: import_v46.z.object({ tokens: import_v46.z.number() }).nullish(),
-      providerMetadata: import_v46.z.record(import_v46.z.string(), import_v46.z.record(import_v46.z.string(), import_v46.z.unknown())).optional()
+var gatewayEmbeddingWarningSchema = z8.discriminatedUnion("type", [
+  z8.object({
+    type: z8.literal("unsupported"),
+    feature: z8.string(),
+    details: z8.string().optional()
+  }),
+  z8.object({
+    type: z8.literal("compatibility"),
+    feature: z8.string(),
+    details: z8.string().optional()
+  }),
+  z8.object({
+    type: z8.literal("deprecated"),
+    setting: z8.string(),
+    message: z8.string()
+  }),
+  z8.object({
+    type: z8.literal("other"),
+    message: z8.string()
+  })
+]);
+var gatewayEmbeddingResponseSchema = lazySchema7(
+  () => zodSchema7(
+    z8.object({
+      embeddings: z8.array(z8.array(z8.number())),
+      usage: z8.object({ tokens: z8.number() }).nullish(),
+      warnings: z8.array(gatewayEmbeddingWarningSchema).optional(),
+      providerMetadata: z8.record(z8.string(), z8.record(z8.string(), z8.unknown())).optional()
     })
   )
 );
 
 // src/gateway-image-model.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
-var GatewayImageModel = class {
+import {
+  combineHeaders as combineHeaders3,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler as createJsonResponseHandler6,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler6,
+  postJsonToApi as postJsonToApi3,
+  resolve as resolve6,
+  serializeModelOptions as serializeModelOptions3,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3
+} from "@ai-sdk/provider-utils";
+import { z as z9 } from "zod/v4";
+var GatewayImageModel = class _GatewayImageModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
     // Set a very large number to prevent client-side splitting of requests
     this.maxImagesPerCall = Number.MAX_SAFE_INTEGER;
   }
+  static [WORKFLOW_SERIALIZE3](model) {
+    return serializeModelOptions3({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE3](options) {
+    return new _GatewayImageModel(options.modelId, options.config);
+  }
   get provider() {
     return this.config.provider;
   }
@@ -830,20 +1260,16 @@ var GatewayImageModel = class {
     headers,
     abortSignal
   }) {
-    var _a9, _b9, _c, _d;
-    const resolvedHeaders = await (0, import_provider_utils7.resolve)(this.config.headers());
+    var _a11, _b11, _c, _d;
+    const resolvedHeaders = this.config.headers ? await resolve6(this.config.headers) : void 0;
     try {
-      const {
-        responseHeaders,
-        value: responseBody,
-        rawValue
-      } = await (0, import_provider_utils7.postJsonToApi)({
+      const { responseHeaders, value: responseBody } = await postJsonToApi3({
         url: this.getUrl(),
-        headers: (0, import_provider_utils7.combineHeaders)(
+        headers: combineHeaders3(
           resolvedHeaders,
           headers != null ? headers : {},
           this.getModelConfigHeaders(),
-          await (0, import_provider_utils7.resolve)(this.config.o11yHeaders)
+          await resolve6(this.config.o11yHeaders)
         ),
         body: {
           prompt,
@@ -857,11 +1283,11 @@ var GatewayImageModel = class {
           },
           ...mask && { mask: maybeEncodeImageFile(mask) }
         },
-        successfulResponseHandler: (0, import_provider_utils7.createJsonResponseHandler)(
+        successfulResponseHandler: createJsonResponseHandler6(
           gatewayImageResponseSchema
         ),
-        failedResponseHandler: (0, import_provider_utils7.createJsonErrorResponseHandler)({
-          errorSchema: import_v47.z.any(),
+        failedResponseHandler: createJsonErrorResponseHandler6({
+          errorSchema: z9.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -870,7 +1296,7 @@ var GatewayImageModel = class {
       return {
         images: responseBody.images,
         // Always base64 strings from server
-        warnings: (_a9 = responseBody.warnings) != null ? _a9 : [],
+        warnings: (_a11 = responseBody.warnings) != null ? _a11 : [],
         providerMetadata: responseBody.providerMetadata,
         response: {
           timestamp: /* @__PURE__ */ new Date(),
@@ -879,14 +1305,17 @@ var GatewayImageModel = class {
         },
         ...responseBody.usage != null && {
           usage: {
-            inputTokens: (_b9 = responseBody.usage.inputTokens) != null ? _b9 : void 0,
+            inputTokens: (_b11 = responseBody.usage.inputTokens) != null ? _b11 : void 0,
             outputTokens: (_c = responseBody.usage.outputTokens) != null ? _c : void 0,
             totalTokens: (_d = responseBody.usage.totalTokens) != null ? _d : void 0
           }
         }
       };
     } catch (error) {
-      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders != null ? resolvedHeaders : {})
+      );
     }
   }
   getUrl() {
@@ -894,7 +1323,7 @@ var GatewayImageModel = class {
   }
   getModelConfigHeaders() {
     return {
-      "ai-image-model-specification-version": "3",
+      "ai-image-model-specification-version": "4",
       "ai-model-id": this.modelId
     };
   }
@@ -903,52 +1332,66 @@ function maybeEncodeImageFile(file) {
   if (file.type === "file" && file.data instanceof Uint8Array) {
     return {
       ...file,
-      data: (0, import_provider_utils7.convertUint8ArrayToBase64)(file.data)
+      data: convertUint8ArrayToBase64(file.data)
     };
   }
   return file;
 }
-var providerMetadataEntrySchema = import_v47.z.object({
-  images: import_v47.z.array(import_v47.z.unknown()).optional()
-}).catchall(import_v47.z.unknown());
-var gatewayImageWarningSchema = import_v47.z.discriminatedUnion("type", [
-  import_v47.z.object({
-    type: import_v47.z.literal("unsupported"),
-    feature: import_v47.z.string(),
-    details: import_v47.z.string().optional()
+var providerMetadataEntrySchema = z9.object({
+  images: z9.array(z9.unknown()).optional()
+}).catchall(z9.unknown());
+var gatewayImageWarningSchema = z9.discriminatedUnion("type", [
+  z9.object({
+    type: z9.literal("unsupported"),
+    feature: z9.string(),
+    details: z9.string().optional()
+  }),
+  z9.object({
+    type: z9.literal("compatibility"),
+    feature: z9.string(),
+    details: z9.string().optional()
   }),
-  import_v47.z.object({
-    type: import_v47.z.literal("compatibility"),
-    feature: import_v47.z.string(),
-    details: import_v47.z.string().optional()
+  z9.object({
+    type: z9.literal("deprecated"),
+    setting: z9.string(),
+    message: z9.string()
   }),
-  import_v47.z.object({
-    type: import_v47.z.literal("other"),
-    message: import_v47.z.string()
+  z9.object({
+    type: z9.literal("other"),
+    message: z9.string()
   })
 ]);
-var gatewayImageUsageSchema = import_v47.z.object({
-  inputTokens: import_v47.z.number().nullish(),
-  outputTokens: import_v47.z.number().nullish(),
-  totalTokens: import_v47.z.number().nullish()
+var gatewayImageUsageSchema = z9.object({
+  inputTokens: z9.number().nullish(),
+  outputTokens: z9.number().nullish(),
+  totalTokens: z9.number().nullish()
 });
-var gatewayImageResponseSchema = import_v47.z.object({
-  images: import_v47.z.array(import_v47.z.string()),
+var gatewayImageResponseSchema = z9.object({
+  images: z9.array(z9.string()),
   // Always base64 strings over the wire
-  warnings: import_v47.z.array(gatewayImageWarningSchema).optional(),
-  providerMetadata: import_v47.z.record(import_v47.z.string(), providerMetadataEntrySchema).optional(),
+  warnings: z9.array(gatewayImageWarningSchema).optional(),
+  providerMetadata: z9.record(z9.string(), providerMetadataEntrySchema).optional(),
   usage: gatewayImageUsageSchema.optional()
 });
 
 // src/gateway-video-model.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
-var import_v48 = require("zod/v4");
+import {
+  APICallError as APICallError2
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders4,
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler7,
+  parseJsonEventStream,
+  postJsonToApi as postJsonToApi4,
+  resolve as resolve7
+} from "@ai-sdk/provider-utils";
+import { z as z10 } from "zod/v4";
 var GatewayVideoModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
     // Set a very large number to prevent client-side splitting of requests
     this.maxVideosPerCall = Number.MAX_SAFE_INTEGER;
   }
@@ -968,16 +1411,16 @@ var GatewayVideoModel = class {
     headers,
     abortSignal
   }) {
-    var _a9;
-    const resolvedHeaders = await (0, import_provider_utils8.resolve)(this.config.headers());
+    var _a11;
+    const resolvedHeaders = this.config.headers ? await resolve7(this.config.headers) : void 0;
     try {
-      const { responseHeaders, value: responseBody } = await (0, import_provider_utils8.postJsonToApi)({
+      const { responseHeaders, value: responseBody } = await postJsonToApi4({
         url: this.getUrl(),
-        headers: (0, import_provider_utils8.combineHeaders)(
+        headers: combineHeaders4(
           resolvedHeaders,
           headers != null ? headers : {},
           this.getModelConfigHeaders(),
-          await (0, import_provider_utils8.resolve)(this.config.o11yHeaders),
+          await resolve7(this.config.o11yHeaders),
           { accept: "text/event-stream" }
         ),
         body: {
@@ -997,14 +1440,14 @@ var GatewayVideoModel = class {
           requestBodyValues
         }) => {
           if (response.body == null) {
-            throw new import_provider2.APICallError({
+            throw new APICallError2({
               message: "SSE response body is empty",
               url,
               requestBodyValues,
               statusCode: response.status
             });
           }
-          const eventStream = (0, import_provider_utils8.parseJsonEventStream)({
+          const eventStream = parseJsonEventStream({
             stream: response.body,
             schema: gatewayVideoEventSchema
           });
@@ -1012,7 +1455,7 @@ var GatewayVideoModel = class {
           const { done, value: parseResult } = await reader.read();
           reader.releaseLock();
           if (done || !parseResult) {
-            throw new import_provider2.APICallError({
+            throw new APICallError2({
               message: "SSE stream ended without a data event",
               url,
               requestBodyValues,
@@ -1020,7 +1463,7 @@ var GatewayVideoModel = class {
             });
           }
           if (!parseResult.success) {
-            throw new import_provider2.APICallError({
+            throw new APICallError2({
               message: "Failed to parse video SSE event",
               cause: parseResult.error,
               url,
@@ -1030,7 +1473,7 @@ var GatewayVideoModel = class {
           }
           const event = parseResult.value;
           if (event.type === "error") {
-            throw new import_provider2.APICallError({
+            throw new APICallError2({
               message: event.message,
               statusCode: event.statusCode,
               url,
@@ -1055,8 +1498,8 @@ var GatewayVideoModel = class {
             responseHeaders: Object.fromEntries([...response.headers])
           };
         },
-        failedResponseHandler: (0, import_provider_utils8.createJsonErrorResponseHandler)({
-          errorSchema: import_v48.z.any(),
+        failedResponseHandler: createJsonErrorResponseHandler7({
+          errorSchema: z10.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -1064,7 +1507,7 @@ var GatewayVideoModel = class {
       });
       return {
         videos: responseBody.videos,
-        warnings: (_a9 = responseBody.warnings) != null ? _a9 : [],
+        warnings: (_a11 = responseBody.warnings) != null ? _a11 : [],
         providerMetadata: responseBody.providerMetadata,
         response: {
           timestamp: /* @__PURE__ */ new Date(),
@@ -1073,7 +1516,10 @@ var GatewayVideoModel = class {
         }
       };
     } catch (error) {
-      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders != null ? resolvedHeaders : {})
+      );
     }
   }
   getUrl() {
@@ -1081,7 +1527,7 @@ var GatewayVideoModel = class {
   }
   getModelConfigHeaders() {
     return {
-      "ai-video-model-specification-version": "3",
+      "ai-video-model-specification-version": "4",
       "ai-model-id": this.modelId
     };
   }
@@ -1090,116 +1536,541 @@ function maybeEncodeVideoFile(file) {
   if (file.type === "file" && file.data instanceof Uint8Array) {
     return {
       ...file,
-      data: (0, import_provider_utils8.convertUint8ArrayToBase64)(file.data)
+      data: convertUint8ArrayToBase642(file.data)
     };
   }
   return file;
 }
-var providerMetadataEntrySchema2 = import_v48.z.object({
-  videos: import_v48.z.array(import_v48.z.unknown()).optional()
-}).catchall(import_v48.z.unknown());
-var gatewayVideoDataSchema = import_v48.z.union([
-  import_v48.z.object({
-    type: import_v48.z.literal("url"),
-    url: import_v48.z.string(),
-    mediaType: import_v48.z.string()
+var providerMetadataEntrySchema2 = z10.object({
+  videos: z10.array(z10.unknown()).optional()
+}).catchall(z10.unknown());
+var gatewayVideoDataSchema = z10.union([
+  z10.object({
+    type: z10.literal("url"),
+    url: z10.string(),
+    mediaType: z10.string()
+  }),
+  z10.object({
+    type: z10.literal("base64"),
+    data: z10.string(),
+    mediaType: z10.string()
+  })
+]);
+var gatewayVideoWarningSchema = z10.discriminatedUnion("type", [
+  z10.object({
+    type: z10.literal("unsupported"),
+    feature: z10.string(),
+    details: z10.string().optional()
+  }),
+  z10.object({
+    type: z10.literal("compatibility"),
+    feature: z10.string(),
+    details: z10.string().optional()
+  }),
+  z10.object({
+    type: z10.literal("deprecated"),
+    setting: z10.string(),
+    message: z10.string()
+  }),
+  z10.object({
+    type: z10.literal("other"),
+    message: z10.string()
+  })
+]);
+var gatewayVideoEventSchema = z10.discriminatedUnion("type", [
+  z10.object({
+    type: z10.literal("result"),
+    videos: z10.array(gatewayVideoDataSchema),
+    warnings: z10.array(gatewayVideoWarningSchema).optional(),
+    providerMetadata: z10.record(z10.string(), providerMetadataEntrySchema2).optional()
+  }),
+  z10.object({
+    type: z10.literal("error"),
+    message: z10.string(),
+    errorType: z10.string(),
+    statusCode: z10.number(),
+    param: z10.unknown().nullable()
+  })
+]);
+
+// src/gateway-reranking-model.ts
+import {
+  combineHeaders as combineHeaders5,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler8,
+  createJsonResponseHandler as createJsonResponseHandler7,
+  lazySchema as lazySchema8,
+  postJsonToApi as postJsonToApi5,
+  resolve as resolve8,
+  zodSchema as zodSchema8
+} from "@ai-sdk/provider-utils";
+import { z as z11 } from "zod/v4";
+var GatewayRerankingModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doRerank({
+    documents,
+    query,
+    topN,
+    headers,
+    abortSignal,
+    providerOptions
+  }) {
+    var _a11;
+    const resolvedHeaders = this.config.headers ? await resolve8(this.config.headers) : void 0;
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue
+      } = await postJsonToApi5({
+        url: this.getUrl(),
+        headers: combineHeaders5(
+          resolvedHeaders,
+          headers != null ? headers : {},
+          this.getModelConfigHeaders(),
+          await resolve8(this.config.o11yHeaders)
+        ),
+        body: {
+          documents,
+          query,
+          ...topN != null ? { topN } : {},
+          ...providerOptions ? { providerOptions } : {}
+        },
+        successfulResponseHandler: createJsonResponseHandler7(
+          gatewayRerankingResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler8({
+          errorSchema: z11.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        ranking: responseBody.ranking,
+        providerMetadata: responseBody.providerMetadata,
+        response: { headers: responseHeaders, body: rawValue },
+        warnings: (_a11 = responseBody.warnings) != null ? _a11 : []
+      };
+    } catch (error) {
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders != null ? resolvedHeaders : {})
+      );
+    }
+  }
+  getUrl() {
+    return `${this.config.baseURL}/reranking-model`;
+  }
+  getModelConfigHeaders() {
+    return {
+      "ai-reranking-model-specification-version": "4",
+      "ai-model-id": this.modelId
+    };
+  }
+};
+var gatewayRerankingWarningSchema = z11.discriminatedUnion("type", [
+  z11.object({
+    type: z11.literal("unsupported"),
+    feature: z11.string(),
+    details: z11.string().optional()
+  }),
+  z11.object({
+    type: z11.literal("compatibility"),
+    feature: z11.string(),
+    details: z11.string().optional()
   }),
-  import_v48.z.object({
-    type: import_v48.z.literal("base64"),
-    data: import_v48.z.string(),
-    mediaType: import_v48.z.string()
+  z11.object({
+    type: z11.literal("deprecated"),
+    setting: z11.string(),
+    message: z11.string()
+  }),
+  z11.object({
+    type: z11.literal("other"),
+    message: z11.string()
   })
 ]);
-var gatewayVideoWarningSchema = import_v48.z.discriminatedUnion("type", [
-  import_v48.z.object({
-    type: import_v48.z.literal("unsupported"),
-    feature: import_v48.z.string(),
-    details: import_v48.z.string().optional()
+var gatewayRerankingResponseSchema = lazySchema8(
+  () => zodSchema8(
+    z11.object({
+      ranking: z11.array(
+        z11.object({
+          index: z11.number(),
+          relevanceScore: z11.number()
+        })
+      ),
+      warnings: z11.array(gatewayRerankingWarningSchema).optional(),
+      providerMetadata: z11.record(z11.string(), z11.record(z11.string(), z11.unknown())).optional()
+    })
+  )
+);
+
+// src/gateway-speech-model.ts
+import {
+  combineHeaders as combineHeaders6,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler9,
+  createJsonResponseHandler as createJsonResponseHandler8,
+  postJsonToApi as postJsonToApi6,
+  resolve as resolve9
+} from "@ai-sdk/provider-utils";
+import { z as z12 } from "zod/v4";
+var GatewaySpeechModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    text,
+    voice,
+    outputFormat,
+    instructions,
+    speed,
+    language,
+    providerOptions,
+    headers,
+    abortSignal
+  }) {
+    var _a11;
+    const resolvedHeaders = this.config.headers ? await resolve9(this.config.headers) : void 0;
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue
+      } = await postJsonToApi6({
+        url: this.getUrl(),
+        headers: combineHeaders6(
+          resolvedHeaders,
+          headers != null ? headers : {},
+          this.getModelConfigHeaders(),
+          await resolve9(this.config.o11yHeaders)
+        ),
+        body: {
+          text,
+          ...voice && { voice },
+          ...outputFormat && { outputFormat },
+          ...instructions && { instructions },
+          ...speed != null && { speed },
+          ...language && { language },
+          ...providerOptions && { providerOptions }
+        },
+        successfulResponseHandler: createJsonResponseHandler8(
+          gatewaySpeechResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler9({
+          errorSchema: z12.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        audio: responseBody.audio,
+        warnings: (_a11 = responseBody.warnings) != null ? _a11 : [],
+        providerMetadata: responseBody.providerMetadata,
+        response: {
+          timestamp: /* @__PURE__ */ new Date(),
+          modelId: this.modelId,
+          headers: responseHeaders,
+          body: rawValue
+        }
+      };
+    } catch (error) {
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders != null ? resolvedHeaders : {})
+      );
+    }
+  }
+  getUrl() {
+    return `${this.config.baseURL}/speech-model`;
+  }
+  getModelConfigHeaders() {
+    return {
+      "ai-speech-model-specification-version": "4",
+      "ai-model-id": this.modelId
+    };
+  }
+};
+var providerMetadataEntrySchema3 = z12.object({}).catchall(z12.unknown());
+var gatewaySpeechWarningSchema = z12.discriminatedUnion("type", [
+  z12.object({
+    type: z12.literal("unsupported"),
+    feature: z12.string(),
+    details: z12.string().optional()
+  }),
+  z12.object({
+    type: z12.literal("compatibility"),
+    feature: z12.string(),
+    details: z12.string().optional()
   }),
-  import_v48.z.object({
-    type: import_v48.z.literal("compatibility"),
-    feature: import_v48.z.string(),
-    details: import_v48.z.string().optional()
+  z12.object({
+    type: z12.literal("deprecated"),
+    setting: z12.string(),
+    message: z12.string()
   }),
-  import_v48.z.object({
-    type: import_v48.z.literal("other"),
-    message: import_v48.z.string()
+  z12.object({
+    type: z12.literal("other"),
+    message: z12.string()
   })
 ]);
-var gatewayVideoEventSchema = import_v48.z.discriminatedUnion("type", [
-  import_v48.z.object({
-    type: import_v48.z.literal("result"),
-    videos: import_v48.z.array(gatewayVideoDataSchema),
-    warnings: import_v48.z.array(gatewayVideoWarningSchema).optional(),
-    providerMetadata: import_v48.z.record(import_v48.z.string(), providerMetadataEntrySchema2).optional()
+var gatewaySpeechResponseSchema = z12.object({
+  audio: z12.string(),
+  warnings: z12.array(gatewaySpeechWarningSchema).optional(),
+  providerMetadata: z12.record(z12.string(), providerMetadataEntrySchema3).optional()
+});
+
+// src/gateway-transcription-model.ts
+import {
+  combineHeaders as combineHeaders7,
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase643,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler10,
+  createJsonResponseHandler as createJsonResponseHandler9,
+  postJsonToApi as postJsonToApi7,
+  resolve as resolve10
+} from "@ai-sdk/provider-utils";
+import { z as z13 } from "zod/v4";
+var GatewayTranscriptionModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    audio,
+    mediaType,
+    providerOptions,
+    headers,
+    abortSignal
+  }) {
+    var _a11, _b11, _c, _d;
+    const resolvedHeaders = this.config.headers ? await resolve10(this.config.headers) : void 0;
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue
+      } = await postJsonToApi7({
+        url: this.getUrl(),
+        headers: combineHeaders7(
+          resolvedHeaders,
+          headers != null ? headers : {},
+          this.getModelConfigHeaders(),
+          await resolve10(this.config.o11yHeaders)
+        ),
+        body: {
+          audio: audio instanceof Uint8Array ? convertUint8ArrayToBase643(audio) : audio,
+          mediaType,
+          ...providerOptions && { providerOptions }
+        },
+        successfulResponseHandler: createJsonResponseHandler9(
+          gatewayTranscriptionResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler10({
+          errorSchema: z13.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        text: responseBody.text,
+        segments: (_a11 = responseBody.segments) != null ? _a11 : [],
+        language: (_b11 = responseBody.language) != null ? _b11 : void 0,
+        durationInSeconds: (_c = responseBody.durationInSeconds) != null ? _c : void 0,
+        warnings: (_d = responseBody.warnings) != null ? _d : [],
+        providerMetadata: responseBody.providerMetadata,
+        response: {
+          timestamp: /* @__PURE__ */ new Date(),
+          modelId: this.modelId,
+          headers: responseHeaders,
+          body: rawValue
+        }
+      };
+    } catch (error) {
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(resolvedHeaders != null ? resolvedHeaders : {})
+      );
+    }
+  }
+  getUrl() {
+    return `${this.config.baseURL}/transcription-model`;
+  }
+  getModelConfigHeaders() {
+    return {
+      "ai-transcription-model-specification-version": "4",
+      "ai-model-id": this.modelId
+    };
+  }
+};
+var providerMetadataEntrySchema4 = z13.object({}).catchall(z13.unknown());
+var gatewayTranscriptionWarningSchema = z13.discriminatedUnion("type", [
+  z13.object({
+    type: z13.literal("unsupported"),
+    feature: z13.string(),
+    details: z13.string().optional()
+  }),
+  z13.object({
+    type: z13.literal("compatibility"),
+    feature: z13.string(),
+    details: z13.string().optional()
   }),
-  import_v48.z.object({
-    type: import_v48.z.literal("error"),
-    message: import_v48.z.string(),
-    errorType: import_v48.z.string(),
-    statusCode: import_v48.z.number(),
-    param: import_v48.z.unknown().nullable()
+  z13.object({
+    type: z13.literal("deprecated"),
+    setting: z13.string(),
+    message: z13.string()
+  }),
+  z13.object({
+    type: z13.literal("other"),
+    message: z13.string()
   })
 ]);
+var gatewayTranscriptionResponseSchema = z13.object({
+  text: z13.string(),
+  segments: z13.array(
+    z13.object({
+      text: z13.string(),
+      startSecond: z13.number(),
+      endSecond: z13.number()
+    })
+  ).optional(),
+  language: z13.string().nullish(),
+  durationInSeconds: z13.number().nullish(),
+  warnings: z13.array(gatewayTranscriptionWarningSchema).optional(),
+  providerMetadata: z13.record(z13.string(), providerMetadataEntrySchema4).optional()
+});
+
+// src/gateway-realtime-model.ts
+var GatewayRealtimeModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v4";
+    this.modelId = modelId;
+    this.provider = config.provider;
+    this.config = config;
+  }
+  /**
+   * Mints a single-use, short-lived client secret (`vcst_`) the browser uses to
+   * open the realtime WebSocket without ever holding the long-lived Gateway
+   * credential. The customer's server calls this (via
+   * `gateway.experimental_realtime.getToken`) and hands the returned token to
+   * the browser, which connects with it through the `ai-gateway-auth.<token>`
+   * subprotocol. `expiresAfterSeconds` is forwarded to the mint endpoint;
+   * `sessionConfig` is intentionally unused here — it is applied later via the
+   * normalized `session-update` event.
+   */
+  async doCreateClientSecret(options) {
+    const secret = await this.config.createClientSecret({
+      modelId: this.modelId,
+      ...(options == null ? void 0 : options.expiresAfterSeconds) != null && {
+        expiresAfterSeconds: options.expiresAfterSeconds
+      }
+    });
+    return {
+      token: secret.token,
+      url: toGatewayRealtimeUrl(this.config.baseURL, this.modelId),
+      ...secret.expiresAt != null && { expiresAt: secret.expiresAt }
+    };
+  }
+  getWebSocketConfig(options) {
+    return {
+      url: options.url,
+      protocols: getGatewayRealtimeProtocols(options.token, {
+        teamIdOrSlug: this.config.teamIdOrSlug
+      })
+    };
+  }
+  parseServerEvent(raw) {
+    return raw;
+  }
+  serializeClientEvent(event) {
+    return event;
+  }
+  buildSessionConfig(config) {
+    return config;
+  }
+};
+function toGatewayRealtimeUrl(baseURL, modelId) {
+  const url = new URL(`${baseURL.replace(/^http/, "ws")}/realtime-model`);
+  url.searchParams.set("ai-model-id", modelId);
+  return url.toString();
+}
 
 // src/tool/parallel-search.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
-var import_zod = require("zod");
-var parallelSearchInputSchema = (0, import_provider_utils9.lazySchema)(
-  () => (0, import_provider_utils9.zodSchema)(
-    import_zod.z.object({
-      objective: import_zod.z.string().describe(
+import {
+  createProviderExecutedToolFactory,
+  lazySchema as lazySchema9,
+  zodSchema as zodSchema9
+} from "@ai-sdk/provider-utils";
+import { z as z14 } from "zod";
+var parallelSearchInputSchema = lazySchema9(
+  () => zodSchema9(
+    z14.object({
+      objective: z14.string().describe(
         "Natural-language description of the web research goal, including source or freshness guidance and broader context from the task. Maximum 5000 characters."
       ),
-      search_queries: import_zod.z.array(import_zod.z.string()).optional().describe(
+      search_queries: z14.array(z14.string()).optional().describe(
         "Optional search queries to supplement the objective. Maximum 200 characters per query."
       ),
-      mode: import_zod.z.enum(["one-shot", "agentic"]).optional().describe(
+      mode: z14.enum(["one-shot", "agentic"]).optional().describe(
         'Mode preset: "one-shot" for comprehensive results with longer excerpts (default), "agentic" for concise, token-efficient results for multi-step workflows.'
       ),
-      max_results: import_zod.z.number().optional().describe(
+      max_results: z14.number().optional().describe(
         "Maximum number of results to return (1-20). Defaults to 10 if not specified."
       ),
-      source_policy: import_zod.z.object({
-        include_domains: import_zod.z.array(import_zod.z.string()).optional().describe("List of domains to include in search results."),
-        exclude_domains: import_zod.z.array(import_zod.z.string()).optional().describe("List of domains to exclude from search results."),
-        after_date: import_zod.z.string().optional().describe(
+      source_policy: z14.object({
+        include_domains: z14.array(z14.string()).optional().describe("List of domains to include in search results."),
+        exclude_domains: z14.array(z14.string()).optional().describe("List of domains to exclude from search results."),
+        after_date: z14.string().optional().describe(
           "Only include results published after this date (ISO 8601 format)."
         )
       }).optional().describe(
         "Source policy for controlling which domains to include/exclude and freshness."
       ),
-      excerpts: import_zod.z.object({
-        max_chars_per_result: import_zod.z.number().optional().describe("Maximum characters per result."),
-        max_chars_total: import_zod.z.number().optional().describe("Maximum total characters across all results.")
+      excerpts: z14.object({
+        max_chars_per_result: z14.number().optional().describe("Maximum characters per result."),
+        max_chars_total: z14.number().optional().describe("Maximum total characters across all results.")
       }).optional().describe("Excerpt configuration for controlling result length."),
-      fetch_policy: import_zod.z.object({
-        max_age_seconds: import_zod.z.number().optional().describe(
+      fetch_policy: z14.object({
+        max_age_seconds: z14.number().optional().describe(
           "Maximum age in seconds for cached content. Set to 0 to always fetch fresh content."
         )
       }).optional().describe("Fetch policy for controlling content freshness.")
     })
   )
 );
-var parallelSearchOutputSchema = (0, import_provider_utils9.lazySchema)(
-  () => (0, import_provider_utils9.zodSchema)(
-    import_zod.z.union([
+var parallelSearchOutputSchema = lazySchema9(
+  () => zodSchema9(
+    z14.union([
       // Success response
-      import_zod.z.object({
-        searchId: import_zod.z.string(),
-        results: import_zod.z.array(
-          import_zod.z.object({
-            url: import_zod.z.string(),
-            title: import_zod.z.string(),
-            excerpt: import_zod.z.string(),
-            publishDate: import_zod.z.string().nullable().optional(),
-            relevanceScore: import_zod.z.number().optional()
+      z14.object({
+        searchId: z14.string(),
+        results: z14.array(
+          z14.object({
+            url: z14.string(),
+            title: z14.string(),
+            excerpt: z14.string(),
+            publishDate: z14.string().nullable().optional(),
+            relevanceScore: z14.number().optional()
           })
         )
       }),
       // Error response
-      import_zod.z.object({
-        error: import_zod.z.enum([
+      z14.object({
+        error: z14.enum([
           "api_error",
           "rate_limit",
           "timeout",
@@ -1207,13 +2078,13 @@ var parallelSearchOutputSchema = (0, import_provider_utils9.lazySchema)(
           "configuration_error",
           "unknown"
         ]),
-        statusCode: import_zod.z.number().optional(),
-        message: import_zod.z.string()
+        statusCode: z14.number().optional(),
+        message: z14.string()
       })
     ])
   )
 );
-var parallelSearchToolFactory = (0, import_provider_utils9.createProviderToolFactoryWithOutputSchema)({
+var parallelSearchToolFactory = createProviderExecutedToolFactory({
   id: "gateway.parallel_search",
   inputSchema: parallelSearchInputSchema,
   outputSchema: parallelSearchOutputSchema
@@ -1221,82 +2092,86 @@ var parallelSearchToolFactory = (0, import_provider_utils9.createProviderToolFac
 var parallelSearch = (config = {}) => parallelSearchToolFactory(config);
 
 // src/tool/perplexity-search.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
-var perplexitySearchInputSchema = (0, import_provider_utils10.lazySchema)(
-  () => (0, import_provider_utils10.zodSchema)(
-    import_zod2.z.object({
-      query: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.array(import_zod2.z.string())]).describe(
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory2,
+  lazySchema as lazySchema10,
+  zodSchema as zodSchema10
+} from "@ai-sdk/provider-utils";
+import { z as z15 } from "zod";
+var perplexitySearchInputSchema = lazySchema10(
+  () => zodSchema10(
+    z15.object({
+      query: z15.union([z15.string(), z15.array(z15.string())]).describe(
         "Search query (string) or multiple queries (array of up to 5 strings). Multi-query searches return combined results from all queries."
       ),
-      max_results: import_zod2.z.number().optional().describe(
+      max_results: z15.number().optional().describe(
         "Maximum number of search results to return (1-20, default: 10)"
       ),
-      max_tokens_per_page: import_zod2.z.number().optional().describe(
+      max_tokens_per_page: z15.number().optional().describe(
         "Maximum number of tokens to extract per search result page (256-2048, default: 2048)"
       ),
-      max_tokens: import_zod2.z.number().optional().describe(
+      max_tokens: z15.number().optional().describe(
         "Maximum total tokens across all search results (default: 25000, max: 1000000)"
       ),
-      country: import_zod2.z.string().optional().describe(
+      country: z15.string().optional().describe(
         "Two-letter ISO 3166-1 alpha-2 country code for regional search results (e.g., 'US', 'GB', 'FR')"
       ),
-      search_domain_filter: import_zod2.z.array(import_zod2.z.string()).optional().describe(
+      search_domain_filter: z15.array(z15.string()).optional().describe(
         "List of domains to include or exclude from search results (max 20). To include: ['nature.com', 'science.org']. To exclude: ['-example.com', '-spam.net']"
       ),
-      search_language_filter: import_zod2.z.array(import_zod2.z.string()).optional().describe(
+      search_language_filter: z15.array(z15.string()).optional().describe(
         "List of ISO 639-1 language codes to filter results (max 10, lowercase). Examples: ['en', 'fr', 'de']"
       ),
-      search_after_date: import_zod2.z.string().optional().describe(
+      search_after_date: z15.string().optional().describe(
         "Include only results published after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
       ),
-      search_before_date: import_zod2.z.string().optional().describe(
+      search_before_date: z15.string().optional().describe(
         "Include only results published before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
       ),
-      last_updated_after_filter: import_zod2.z.string().optional().describe(
+      last_updated_after_filter: z15.string().optional().describe(
         "Include only results last updated after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
       ),
-      last_updated_before_filter: import_zod2.z.string().optional().describe(
+      last_updated_before_filter: z15.string().optional().describe(
         "Include only results last updated before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
       ),
-      search_recency_filter: import_zod2.z.enum(["day", "week", "month", "year"]).optional().describe(
+      search_recency_filter: z15.enum(["day", "week", "month", "year"]).optional().describe(
         "Filter results by relative time period. Cannot be used with search_after_date or search_before_date."
       )
     })
   )
 );
-var perplexitySearchOutputSchema = (0, import_provider_utils10.lazySchema)(
-  () => (0, import_provider_utils10.zodSchema)(
-    import_zod2.z.union([
+var perplexitySearchOutputSchema = lazySchema10(
+  () => zodSchema10(
+    z15.union([
       // Success response
-      import_zod2.z.object({
-        results: import_zod2.z.array(
-          import_zod2.z.object({
-            title: import_zod2.z.string(),
-            url: import_zod2.z.string(),
-            snippet: import_zod2.z.string(),
-            date: import_zod2.z.string().optional(),
-            lastUpdated: import_zod2.z.string().optional()
+      z15.object({
+        results: z15.array(
+          z15.object({
+            title: z15.string(),
+            url: z15.string(),
+            snippet: z15.string(),
+            date: z15.string().optional(),
+            lastUpdated: z15.string().optional()
           })
         ),
-        id: import_zod2.z.string()
+        id: z15.string()
       }),
       // Error response
-      import_zod2.z.object({
-        error: import_zod2.z.enum([
+      z15.object({
+        error: z15.enum([
           "api_error",
           "rate_limit",
           "timeout",
           "invalid_input",
           "unknown"
         ]),
-        statusCode: import_zod2.z.number().optional(),
-        message: import_zod2.z.string()
+        statusCode: z15.number().optional(),
+        message: z15.string()
       })
     ])
   )
 );
-var perplexitySearchToolFactory = (0, import_provider_utils10.createProviderToolFactoryWithOutputSchema)({
+var perplexitySearchToolFactory = createProviderExecutedToolFactory2({
   id: "gateway.perplexity_search",
   inputSchema: perplexitySearchInputSchema,
   outputSchema: perplexitySearchOutputSchema
@@ -1325,40 +2200,54 @@ var gatewayTools = {
 };
 
 // src/vercel-environment.ts
-var import_oidc = require("@vercel/oidc");
-var import_oidc2 = require("@vercel/oidc");
+import { getContext } from "@vercel/oidc";
+import { getVercelOidcToken } from "@vercel/oidc";
 async function getVercelRequestId() {
-  var _a9;
-  return (_a9 = (0, import_oidc.getContext)().headers) == null ? void 0 : _a9["x-vercel-id"];
+  var _a11;
+  return (_a11 = getContext().headers) == null ? void 0 : _a11["x-vercel-id"];
 }
 
-// src/gateway-provider.ts
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
-
 // src/version.ts
-var VERSION = true ? "4.0.0-beta.10" : "0.0.0-test";
+var VERSION = true ? "4.0.0-beta.109" : "0.0.0-test";
 
 // src/gateway-provider.ts
 var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
-function createGatewayProvider(options = {}) {
-  var _a9, _b9;
+var gatewayClientSecretResponseSchema = z16.object({
+  token: z16.string(),
+  expiresAt: z16.number().nullish()
+});
+function createGateway(options = {}) {
+  var _a11, _b11;
   let pendingMetadata = null;
   let metadataCache = null;
-  const cacheRefreshMillis = (_a9 = options.metadataCacheRefreshMillis) != null ? _a9 : 1e3 * 60 * 5;
+  const cacheRefreshMillis = (_a11 = options.metadataCacheRefreshMillis) != null ? _a11 : 1e3 * 60 * 5;
   let lastFetchTime = 0;
-  const baseURL = (_b9 = (0, import_provider_utils11.withoutTrailingSlash)(options.baseURL)) != null ? _b9 : "https://ai-gateway.vercel.sh/v3/ai";
+  const baseURL = (_b11 = withoutTrailingSlash(options.baseURL)) != null ? _b11 : "https://ai-gateway.vercel.sh/v4/ai";
+  const createAuthHeaders = (auth) => withUserAgentSuffix(
+    {
+      Authorization: `Bearer ${auth.token}`,
+      "ai-gateway-protocol-version": AI_GATEWAY_PROTOCOL_VERSION,
+      [GATEWAY_AUTH_METHOD_HEADER]: auth.authMethod,
+      ...options.teamIdOrSlug != null ? { [VERCEL_AI_GATEWAY_TEAM_HEADER]: options.teamIdOrSlug } : {},
+      ...options.headers
+    },
+    `ai-sdk/gateway/${VERSION}`
+  );
   const getHeaders = async () => {
     try {
-      const auth = await getGatewayAuthToken(options);
-      return (0, import_provider_utils12.withUserAgentSuffix)(
-        {
-          Authorization: `Bearer ${auth.token}`,
-          "ai-gateway-protocol-version": AI_GATEWAY_PROTOCOL_VERSION,
-          [GATEWAY_AUTH_METHOD_HEADER]: auth.authMethod,
-          ...options.headers
-        },
-        `ai-sdk/gateway/${VERSION}`
-      );
+      return createAuthHeaders(await getGatewayAuthToken(options));
+    } catch (error) {
+      throw GatewayAuthenticationError.createContextualError({
+        apiKeyProvided: false,
+        oidcTokenProvided: false,
+        statusCode: 401,
+        cause: error
+      });
+    }
+  };
+  const getRealtimeAuthToken = async () => {
+    try {
+      return await getGatewayAuthToken(options);
     } catch (error) {
       throw GatewayAuthenticationError.createContextualError({
         apiKeyProvided: false,
@@ -1368,20 +2257,52 @@ function createGatewayProvider(options = {}) {
       });
     }
   };
+  const mintRealtimeClientSecret = async (params) => {
+    assertGatewayRealtimeServerEnvironment();
+    const auth = await getRealtimeAuthToken();
+    const headers = createAuthHeaders(auth);
+    const url = new URL("/v1/realtime/client-secrets", baseURL).toString();
+    try {
+      const { value } = await postJsonToApi8({
+        url,
+        headers,
+        body: {
+          model: params.modelId,
+          ...params.expiresAfterSeconds != null && {
+            expiresIn: params.expiresAfterSeconds
+          }
+        },
+        successfulResponseHandler: createJsonResponseHandler10(
+          gatewayClientSecretResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler11({
+          errorSchema: z16.any(),
+          errorToMessage: (data) => data
+        }),
+        fetch: options.fetch
+      });
+      return {
+        token: value.token,
+        ...value.expiresAt != null && { expiresAt: value.expiresAt }
+      };
+    } catch (error) {
+      throw await asGatewayError(error, await parseAuthMethod(headers));
+    }
+  };
   const createO11yHeaders = () => {
-    const deploymentId = (0, import_provider_utils11.loadOptionalSetting)({
+    const deploymentId = loadOptionalSetting({
       settingValue: void 0,
       environmentVariableName: "VERCEL_DEPLOYMENT_ID"
     });
-    const environment = (0, import_provider_utils11.loadOptionalSetting)({
+    const environment = loadOptionalSetting({
       settingValue: void 0,
       environmentVariableName: "VERCEL_ENV"
     });
-    const region = (0, import_provider_utils11.loadOptionalSetting)({
+    const region = loadOptionalSetting({
       settingValue: void 0,
       environmentVariableName: "VERCEL_REGION"
     });
-    const projectId = (0, import_provider_utils11.loadOptionalSetting)({
+    const projectId = loadOptionalSetting({
       settingValue: void 0,
       environmentVariableName: "VERCEL_PROJECT_ID"
     });
@@ -1406,8 +2327,8 @@ function createGatewayProvider(options = {}) {
     });
   };
   const getAvailableModels = async () => {
-    var _a10, _b10, _c;
-    const now = (_c = (_b10 = (_a10 = options._internal) == null ? void 0 : _a10.currentDate) == null ? void 0 : _b10.call(_a10).getTime()) != null ? _c : Date.now();
+    var _a12, _b12, _c;
+    const now = (_c = (_b12 = (_a12 = options._internal) == null ? void 0 : _a12.currentDate) == null ? void 0 : _b12.call(_a12).getTime()) != null ? _c : Date.now();
     if (!pendingMetadata || now - lastFetchTime > cacheRefreshMillis) {
       lastFetchTime = now;
       pendingMetadata = new GatewayFetchMetadata({
@@ -1438,6 +2359,30 @@ function createGatewayProvider(options = {}) {
       );
     });
   };
+  const getSpendReport = async (params) => {
+    return new GatewaySpendReport({
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch
+    }).getSpendReport(params).catch(async (error) => {
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(await getHeaders())
+      );
+    });
+  };
+  const getGenerationInfo = async (params) => {
+    return new GatewayGenerationInfoFetcher({
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch
+    }).getGenerationInfo(params).catch(async (error) => {
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(await getHeaders())
+      );
+    });
+  };
   const provider = function(modelId) {
     if (new.target) {
       throw new Error(
@@ -1446,9 +2391,11 @@ function createGatewayProvider(options = {}) {
     }
     return createLanguageModel(modelId);
   };
-  provider.specificationVersion = "v3";
+  provider.specificationVersion = "v4";
   provider.getAvailableModels = getAvailableModels;
   provider.getCredits = getCredits;
+  provider.getSpendReport = getSpendReport;
+  provider.getGenerationInfo = getGenerationInfo;
   provider.imageModel = (modelId) => {
     return new GatewayImageModel(modelId, {
       provider: "gateway",
@@ -1479,6 +2426,60 @@ function createGatewayProvider(options = {}) {
       o11yHeaders: createO11yHeaders()
     });
   };
+  const createRerankingModel = (modelId) => {
+    return new GatewayRerankingModel(modelId, {
+      provider: "gateway",
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders()
+    });
+  };
+  provider.rerankingModel = createRerankingModel;
+  provider.reranking = createRerankingModel;
+  const createSpeechModel = (modelId) => {
+    return new GatewaySpeechModel(modelId, {
+      provider: "gateway",
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders()
+    });
+  };
+  provider.speechModel = createSpeechModel;
+  provider.speech = createSpeechModel;
+  const createTranscriptionModel = (modelId) => {
+    return new GatewayTranscriptionModel(modelId, {
+      provider: "gateway",
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders()
+    });
+  };
+  provider.transcriptionModel = createTranscriptionModel;
+  provider.transcription = createTranscriptionModel;
+  const createRealtimeModel = (modelId) => new GatewayRealtimeModel(modelId, {
+    provider: "gateway.realtime",
+    baseURL,
+    teamIdOrSlug: options.teamIdOrSlug,
+    createClientSecret: mintRealtimeClientSecret
+  });
+  provider.experimental_realtime = Object.assign(
+    (modelId) => createRealtimeModel(modelId),
+    {
+      getToken: async (tokenOptions) => {
+        const { model: modelId, ...secretOptions } = tokenOptions;
+        const model = createRealtimeModel(modelId);
+        const secret = await model.doCreateClientSecret(secretOptions);
+        return {
+          token: secret.token,
+          url: secret.url,
+          ...secret.expiresAt != null && { expiresAt: secret.expiresAt }
+        };
+      }
+    }
+  );
   provider.chat = provider.languageModel;
   provider.embedding = provider.embeddingModel;
   provider.image = provider.imageModel;
@@ -1486,9 +2487,9 @@ function createGatewayProvider(options = {}) {
   provider.tools = gatewayTools;
   return provider;
 }
-var gateway = createGatewayProvider();
+var gateway = createGateway();
 async function getGatewayAuthToken(options) {
-  const apiKey = (0, import_provider_utils11.loadOptionalSetting)({
+  const apiKey = loadOptionalSetting({
     settingValue: options.apiKey,
     environmentVariableName: "AI_GATEWAY_API_KEY"
   });
@@ -1498,23 +2499,38 @@ async function getGatewayAuthToken(options) {
       authMethod: "api-key"
     };
   }
-  const oidcToken = await (0, import_oidc2.getVercelOidcToken)();
+  const oidcToken = await getVercelOidcToken();
   return {
     token: oidcToken,
     authMethod: "oidc"
   };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+function assertGatewayRealtimeServerEnvironment() {
+  if (typeof globalThis.window !== "undefined") {
+    throw new Error(
+      "AI Gateway realtime client secrets must be minted server-side: minting needs your Gateway credential, which must never reach the browser. Call gateway.experimental_realtime.getToken() from your server and pass the returned token to the client."
+    );
+  }
+}
+export {
+  GATEWAY_AUTH_SUBPROTOCOL_PREFIX,
+  GATEWAY_REALTIME_SUBPROTOCOL,
+  GATEWAY_TEAM_SUBPROTOCOL_PREFIX,
   GatewayAuthenticationError,
   GatewayError,
+  GatewayFailedDependencyError,
+  GatewayForbiddenError,
   GatewayInternalServerError,
   GatewayInvalidRequestError,
   GatewayModelNotFoundError,
   GatewayRateLimitError,
   GatewayResponseError,
+  VERSION,
   createGateway,
-  createGatewayProvider,
-  gateway
-});
+  createGateway as createGatewayProvider,
+  gateway,
+  getGatewayRealtimeAuthToken,
+  getGatewayRealtimeProtocols,
+  getGatewayRealtimeTeamIdOrSlug
+};
 //# sourceMappingURL=index.js.map