@ai-sdk/gateway 1.0.36 → 1.0.38

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name7 in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -45,13 +35,13 @@ module.exports = __toCommonJS(src_exports);
 
 // src/gateway-provider.ts
 var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
 
 // src/errors/as-gateway-error.ts
 var import_provider = require("@ai-sdk/provider");
 
 // src/errors/create-gateway-error.ts
-var z2 = __toESM(require("zod/v4"));
+var import_v42 = require("zod/v4");
 
 // src/errors/gateway-error.ts
 var marker = "vercel.ai.gateway.error";
@@ -196,13 +186,18 @@ var GatewayRateLimitError = class extends (_b4 = GatewayError, _a4 = symbol4, _b
 };
 
 // src/errors/gateway-model-not-found-error.ts
-var z = __toESM(require("zod/v4"));
+var import_v4 = require("zod/v4");
+var import_provider_utils = require("@ai-sdk/provider-utils");
 var name4 = "GatewayModelNotFoundError";
 var marker5 = `vercel.ai.gateway.error.${name4}`;
 var symbol5 = Symbol.for(marker5);
-var modelNotFoundParamSchema = z.object({
-  modelId: z.string()
-});
+var modelNotFoundParamSchema = (0, import_provider_utils.lazyValidator)(
+  () => (0, import_provider_utils.zodSchema)(
+    import_v4.z.object({
+      modelId: import_v4.z.string()
+    })
+  )
+);
 var _a5, _b5;
 var GatewayModelNotFoundError = class extends (_b5 = GatewayError, _a5 = symbol5, _b5) {
   constructor({
@@ -272,14 +267,18 @@ var GatewayResponseError = class extends (_b7 = GatewayError, _a7 = symbol7, _b7
 };
 
 // src/errors/create-gateway-error.ts
-function createGatewayErrorFromResponse({
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+async function createGatewayErrorFromResponse({
   response,
   statusCode,
   defaultMessage = "Gateway request failed",
   cause,
   authMethod
 }) {
-  const parseResult = gatewayErrorResponseSchema.safeParse(response);
+  const parseResult = await (0, import_provider_utils2.safeValidateTypes)({
+    value: response,
+    schema: gatewayErrorResponseSchema
+  });
   if (!parseResult.success) {
     return new GatewayResponseError({
       message: `Invalid error response format: ${defaultMessage}`,
@@ -289,7 +288,7 @@ function createGatewayErrorFromResponse({
       cause
     });
   }
-  const validatedResponse = parseResult.data;
+  const validatedResponse = parseResult.value;
   const errorType = validatedResponse.error.type;
   const message = validatedResponse.error.message;
   switch (errorType) {
@@ -305,13 +304,14 @@ function createGatewayErrorFromResponse({
     case "rate_limit_exceeded":
       return new GatewayRateLimitError({ message, statusCode, cause });
     case "model_not_found": {
-      const modelResult = modelNotFoundParamSchema.safeParse(
-        validatedResponse.error.param
-      );
+      const modelResult = await (0, import_provider_utils2.safeValidateTypes)({
+        value: validatedResponse.error.param,
+        schema: modelNotFoundParamSchema
+      });
       return new GatewayModelNotFoundError({
         message,
         statusCode,
-        modelId: modelResult.success ? modelResult.data.modelId : void 0,
+        modelId: modelResult.success ? modelResult.value.modelId : void 0,
         cause
       });
     }
@@ -321,14 +321,18 @@ function createGatewayErrorFromResponse({
       return new GatewayInternalServerError({ message, statusCode, cause });
   }
 }
-var gatewayErrorResponseSchema = z2.object({
-  error: z2.object({
-    message: z2.string(),
-    type: z2.string().nullish(),
-    param: z2.unknown().nullish(),
-    code: z2.union([z2.string(), z2.number()]).nullish()
-  })
-});
+var gatewayErrorResponseSchema = (0, import_provider_utils2.lazyValidator)(
+  () => (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()
+      })
+    })
+  )
+);
 
 // src/errors/as-gateway-error.ts
 function asGatewayError(error, authMethod) {
@@ -370,102 +374,114 @@ function extractApiCallResponse(error) {
 }
 
 // src/errors/parse-auth-method.ts
-var z3 = __toESM(require("zod/v4"));
+var import_v43 = require("zod/v4");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 var GATEWAY_AUTH_METHOD_HEADER = "ai-gateway-auth-method";
-function parseAuthMethod(headers) {
-  const result = gatewayAuthMethodSchema.safeParse(
-    headers[GATEWAY_AUTH_METHOD_HEADER]
-  );
-  return result.success ? result.data : void 0;
+async function parseAuthMethod(headers) {
+  const result = await (0, import_provider_utils3.safeValidateTypes)({
+    value: headers[GATEWAY_AUTH_METHOD_HEADER],
+    schema: gatewayAuthMethodSchema
+  });
+  return result.success ? result.value : void 0;
 }
-var gatewayAuthMethodSchema = z3.union([
-  z3.literal("api-key"),
-  z3.literal("oidc")
-]);
+var gatewayAuthMethodSchema = (0, import_provider_utils3.lazyValidator)(
+  () => (0, import_provider_utils3.zodSchema)(import_v43.z.union([import_v43.z.literal("api-key"), import_v43.z.literal("oidc")]))
+);
 
 // src/gateway-fetch-metadata.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var z4 = __toESM(require("zod/v4"));
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_v44 = require("zod/v4");
 var GatewayFetchMetadata = class {
   constructor(config) {
     this.config = config;
   }
   async getAvailableModels() {
     try {
-      const { value } = await (0, import_provider_utils.getFromApi)({
+      const { value } = await (0, import_provider_utils4.getFromApi)({
         url: `${this.config.baseURL}/config`,
-        headers: await (0, import_provider_utils.resolve)(this.config.headers()),
-        successfulResponseHandler: (0, import_provider_utils.createJsonResponseHandler)(
-          gatewayFetchMetadataSchema
+        headers: await (0, import_provider_utils4.resolve)(this.config.headers()),
+        successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+          gatewayAvailableModelsResponseSchema
         ),
-        failedResponseHandler: (0, import_provider_utils.createJsonErrorResponseHandler)({
-          errorSchema: z4.any(),
+        failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
+          errorSchema: import_v44.z.any(),
           errorToMessage: (data) => data
         }),
         fetch: this.config.fetch
       });
       return value;
     } catch (error) {
-      throw asGatewayError(error);
+      throw await asGatewayError(error);
     }
   }
   async getCredits() {
     try {
       const baseUrl = new URL(this.config.baseURL);
-      const { value } = await (0, import_provider_utils.getFromApi)({
+      const { value } = await (0, import_provider_utils4.getFromApi)({
         url: `${baseUrl.origin}/v1/credits`,
-        headers: await (0, import_provider_utils.resolve)(this.config.headers()),
-        successfulResponseHandler: (0, import_provider_utils.createJsonResponseHandler)(gatewayCreditsSchema),
-        failedResponseHandler: (0, import_provider_utils.createJsonErrorResponseHandler)({
-          errorSchema: z4.any(),
+        headers: await (0, import_provider_utils4.resolve)(this.config.headers()),
+        successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+          gatewayCreditsResponseSchema
+        ),
+        failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
+          errorSchema: import_v44.z.any(),
           errorToMessage: (data) => data
         }),
         fetch: this.config.fetch
       });
       return value;
     } catch (error) {
-      throw asGatewayError(error);
+      throw await asGatewayError(error);
     }
   }
 };
-var gatewayLanguageModelSpecificationSchema = z4.object({
-  specificationVersion: z4.literal("v2"),
-  provider: z4.string(),
-  modelId: z4.string()
-});
-var gatewayLanguageModelPricingSchema = 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,
-  output,
-  ...input_cache_read ? { cachedInputTokens: input_cache_read } : {},
-  ...input_cache_write ? { cacheCreationInputTokens: input_cache_write } : {}
-}));
-var gatewayLanguageModelEntrySchema = z4.object({
-  id: z4.string(),
-  name: z4.string(),
-  description: z4.string().nullish(),
-  pricing: gatewayLanguageModelPricingSchema.nullish(),
-  specification: gatewayLanguageModelSpecificationSchema,
-  modelType: z4.enum(["language", "embedding", "image"]).nullish()
-});
-var gatewayFetchMetadataSchema = z4.object({
-  models: z4.array(gatewayLanguageModelEntrySchema)
-});
-var gatewayCreditsSchema = z4.object({
-  balance: z4.string(),
-  total_used: z4.string()
-}).transform(({ balance, total_used }) => ({
-  balance,
-  totalUsed: total_used
-}));
+var gatewayAvailableModelsResponseSchema = (0, import_provider_utils4.lazyValidator)(
+  () => (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()
+          }).transform(
+            ({ input, output, input_cache_read, input_cache_write }) => ({
+              input,
+              output,
+              ...input_cache_read ? { cachedInputTokens: input_cache_read } : {},
+              ...input_cache_write ? { cacheCreationInputTokens: input_cache_write } : {}
+            })
+          ).nullish(),
+          specification: import_v44.z.object({
+            specificationVersion: import_v44.z.literal("v2"),
+            provider: import_v44.z.string(),
+            modelId: import_v44.z.string()
+          }),
+          modelType: import_v44.z.enum(["language", "embedding", "image"]).nullish()
+        })
+      )
+    })
+  )
+);
+var gatewayCreditsResponseSchema = (0, import_provider_utils4.lazyValidator)(
+  () => (0, import_provider_utils4.zodSchema)(
+    import_v44.z.object({
+      balance: import_v44.z.string(),
+      total_used: import_v44.z.string()
+    }).transform(({ balance, total_used }) => ({
+      balance,
+      totalUsed: total_used
+    }))
+  )
+);
 
 // src/gateway-language-model.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var z5 = __toESM(require("zod/v4"));
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_v45 = require("zod/v4");
 var GatewayLanguageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -486,24 +502,24 @@ var GatewayLanguageModel = class {
   async doGenerate(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await (0, import_provider_utils2.resolve)(this.config.headers());
+    const resolvedHeaders = await (0, import_provider_utils5.resolve)(this.config.headers());
     try {
       const {
         responseHeaders,
         value: responseBody,
         rawValue: rawResponse
-      } = await (0, import_provider_utils2.postJsonToApi)({
+      } = await (0, import_provider_utils5.postJsonToApi)({
         url: this.getUrl(),
-        headers: (0, import_provider_utils2.combineHeaders)(
+        headers: (0, import_provider_utils5.combineHeaders)(
           resolvedHeaders,
           options.headers,
           this.getModelConfigHeaders(this.modelId, false),
-          await (0, import_provider_utils2.resolve)(this.config.o11yHeaders)
+          await (0, import_provider_utils5.resolve)(this.config.o11yHeaders)
         ),
         body: args,
-        successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(z5.any()),
-        failedResponseHandler: (0, import_provider_utils2.createJsonErrorResponseHandler)({
-          errorSchema: z5.any(),
+        successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(import_v45.z.any()),
+        failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
+          errorSchema: import_v45.z.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -516,26 +532,26 @@ var GatewayLanguageModel = class {
         warnings
       };
     } catch (error) {
-      throw asGatewayError(error, parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
     }
   }
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await (0, import_provider_utils2.resolve)(this.config.headers());
+    const resolvedHeaders = await (0, import_provider_utils5.resolve)(this.config.headers());
     try {
-      const { value: response, responseHeaders } = await (0, import_provider_utils2.postJsonToApi)({
+      const { value: response, responseHeaders } = await (0, import_provider_utils5.postJsonToApi)({
         url: this.getUrl(),
-        headers: (0, import_provider_utils2.combineHeaders)(
+        headers: (0, import_provider_utils5.combineHeaders)(
           resolvedHeaders,
           options.headers,
           this.getModelConfigHeaders(this.modelId, true),
-          await (0, import_provider_utils2.resolve)(this.config.o11yHeaders)
+          await (0, import_provider_utils5.resolve)(this.config.o11yHeaders)
         ),
         body: args,
-        successfulResponseHandler: (0, import_provider_utils2.createEventSourceResponseHandler)(z5.any()),
-        failedResponseHandler: (0, import_provider_utils2.createJsonErrorResponseHandler)({
-          errorSchema: z5.any(),
+        successfulResponseHandler: (0, import_provider_utils5.createEventSourceResponseHandler)(import_v45.z.any()),
+        failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
+          errorSchema: import_v45.z.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -571,7 +587,7 @@ var GatewayLanguageModel = class {
         response: { headers: responseHeaders }
       };
     } catch (error) {
-      throw asGatewayError(error, parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
     }
   }
   isFilePart(part) {
@@ -613,8 +629,8 @@ var GatewayLanguageModel = class {
 };
 
 // src/gateway-embedding-model.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var z6 = __toESM(require("zod/v4"));
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var import_v46 = require("zod/v4");
 var GatewayEmbeddingModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -633,29 +649,29 @@ var GatewayEmbeddingModel = class {
     providerOptions
   }) {
     var _a8;
-    const resolvedHeaders = await (0, import_provider_utils3.resolve)(this.config.headers());
+    const resolvedHeaders = await (0, import_provider_utils6.resolve)(this.config.headers());
     try {
       const {
         responseHeaders,
         value: responseBody,
         rawValue
-      } = await (0, import_provider_utils3.postJsonToApi)({
+      } = await (0, import_provider_utils6.postJsonToApi)({
         url: this.getUrl(),
-        headers: (0, import_provider_utils3.combineHeaders)(
+        headers: (0, import_provider_utils6.combineHeaders)(
           resolvedHeaders,
           headers != null ? headers : {},
           this.getModelConfigHeaders(),
-          await (0, import_provider_utils3.resolve)(this.config.o11yHeaders)
+          await (0, import_provider_utils6.resolve)(this.config.o11yHeaders)
         ),
         body: {
           input: values.length === 1 ? values[0] : values,
           ...providerOptions ? { providerOptions } : {}
         },
-        successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+        successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(
           gatewayEmbeddingResponseSchema
         ),
-        failedResponseHandler: (0, import_provider_utils3.createJsonErrorResponseHandler)({
-          errorSchema: z6.any(),
+        failedResponseHandler: (0, import_provider_utils6.createJsonErrorResponseHandler)({
+          errorSchema: import_v46.z.any(),
           errorToMessage: (data) => data
         }),
         ...abortSignal && { abortSignal },
@@ -668,7 +684,7 @@ var GatewayEmbeddingModel = class {
         response: { headers: responseHeaders, body: rawValue }
       };
     } catch (error) {
-      throw asGatewayError(error, parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
     }
   }
   getUrl() {
@@ -681,11 +697,15 @@ var GatewayEmbeddingModel = class {
     };
   }
 };
-var gatewayEmbeddingResponseSchema = z6.object({
-  embeddings: z6.array(z6.array(z6.number())),
-  usage: z6.object({ tokens: z6.number() }).nullish(),
-  providerMetadata: z6.record(z6.string(), z6.record(z6.string(), z6.unknown())).optional()
-});
+var gatewayEmbeddingResponseSchema = (0, import_provider_utils6.lazyValidator)(
+  () => (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()
+    })
+  )
+);
 
 // src/vercel-environment.ts
 var import_oidc = require("@vercel/oidc");
@@ -696,10 +716,10 @@ async function getVercelRequestId() {
 }
 
 // src/gateway-provider.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "1.0.36" : "0.0.0-test";
+var VERSION = true ? "1.0.38" : "0.0.0-test";
 
 // src/gateway-provider.ts
 var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
@@ -709,11 +729,11 @@ function createGatewayProvider(options = {}) {
   let metadataCache = null;
   const cacheRefreshMillis = (_a8 = options.metadataCacheRefreshMillis) != null ? _a8 : 1e3 * 60 * 5;
   let lastFetchTime = 0;
-  const baseURL = (_b8 = (0, import_provider_utils4.withoutTrailingSlash)(options.baseURL)) != null ? _b8 : "https://ai-gateway.vercel.sh/v1/ai";
+  const baseURL = (_b8 = (0, import_provider_utils7.withoutTrailingSlash)(options.baseURL)) != null ? _b8 : "https://ai-gateway.vercel.sh/v1/ai";
   const getHeaders = async () => {
     const auth = await getGatewayAuthToken(options);
     if (auth) {
-      return (0, import_provider_utils5.withUserAgentSuffix)(
+      return (0, import_provider_utils8.withUserAgentSuffix)(
         {
           Authorization: `Bearer ${auth.token}`,
           "ai-gateway-protocol-version": AI_GATEWAY_PROTOCOL_VERSION,
@@ -730,15 +750,15 @@ function createGatewayProvider(options = {}) {
     });
   };
   const createO11yHeaders = () => {
-    const deploymentId = (0, import_provider_utils4.loadOptionalSetting)({
+    const deploymentId = (0, import_provider_utils7.loadOptionalSetting)({
       settingValue: void 0,
       environmentVariableName: "VERCEL_DEPLOYMENT_ID"
     });
-    const environment = (0, import_provider_utils4.loadOptionalSetting)({
+    const environment = (0, import_provider_utils7.loadOptionalSetting)({
       settingValue: void 0,
       environmentVariableName: "VERCEL_ENV"
     });
-    const region = (0, import_provider_utils4.loadOptionalSetting)({
+    const region = (0, import_provider_utils7.loadOptionalSetting)({
       settingValue: void 0,
       environmentVariableName: "VERCEL_REGION"
     });
@@ -774,7 +794,10 @@ function createGatewayProvider(options = {}) {
         metadataCache = metadata;
         return metadata;
       }).catch(async (error) => {
-        throw asGatewayError(error, parseAuthMethod(await getHeaders()));
+        throw await asGatewayError(
+          error,
+          await parseAuthMethod(await getHeaders())
+        );
       });
     }
     return metadataCache ? Promise.resolve(metadataCache) : pendingMetadata;
@@ -785,7 +808,10 @@ function createGatewayProvider(options = {}) {
       headers: getHeaders,
       fetch: options.fetch
     }).getCredits().catch(async (error) => {
-      throw asGatewayError(error, parseAuthMethod(await getHeaders()));
+      throw await asGatewayError(
+        error,
+        await parseAuthMethod(await getHeaders())
+      );
     });
   };
   const provider = function(modelId) {
@@ -815,7 +841,7 @@ function createGatewayProvider(options = {}) {
 }
 var gateway = createGatewayProvider();
 async function getGatewayAuthToken(options) {
-  const apiKey = (0, import_provider_utils4.loadOptionalSetting)({
+  const apiKey = (0, import_provider_utils7.loadOptionalSetting)({
     settingValue: options.apiKey,
     environmentVariableName: "AI_GATEWAY_API_KEY"
   });