@ai-sdk/gateway 0.0.0-02dba89b-20251009204516 → 0.0.0-4115c213-20260122152721

package/dist/index.js

@@ -34,8 +34,7 @@ __export(src_exports, {
 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_utils9 = require("@ai-sdk/provider-utils");
 
 // src/errors/as-gateway-error.ts
 var import_provider = require("@ai-sdk/provider");
@@ -51,12 +50,14 @@ var GatewayError = class _GatewayError extends (_b = Error, _a = symbol, _b) {
   constructor({
     message,
     statusCode = 500,
-    cause
+    cause,
+    generationId
   }) {
-    super(message);
+    super(generationId ? `${message} [${generationId}]` : message);
     this[_a] = true;
     this.statusCode = statusCode;
     this.cause = cause;
+    this.generationId = generationId;
   }
   /**
    * Checks if the given error is a Gateway Error.
@@ -80,9 +81,10 @@ var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b2
   constructor({
     message = "Authentication failed",
     statusCode = 401,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a2] = true;
     // used in isInstance
     this.name = name;
@@ -99,44 +101,37 @@ var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b2
     oidcTokenProvided,
     message = "Authentication failed",
     statusCode = 401,
-    cause
+    cause,
+    generationId
   }) {
     let contextualMessage;
     if (apiKeyProvided) {
-      contextualMessage = `AI Gateway authentication failed: Invalid API key provided.
+      contextualMessage = `AI Gateway authentication failed: Invalid API key.
+
+Create a new API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys
 
-The token is expected to be provided via the 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.`;
+Provide via 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.`;
     } else if (oidcTokenProvided) {
-      contextualMessage = `AI Gateway authentication failed: Invalid OIDC token provided.
+      contextualMessage = `AI Gateway authentication failed: Invalid OIDC token.
 
-The token is expected to be provided via the 'VERCEL_OIDC_TOKEN' environment variable. It expires every 12 hours.
-- make sure your Vercel project settings have OIDC enabled
-- if running locally with 'vercel dev', the token is automatically obtained and refreshed
-- if running locally with your own dev server, run 'vercel env pull' to fetch the token
-- in production/preview, the token is automatically obtained and refreshed
+Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the token.
 
-Alternative: Provide an API key via 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.`;
+Alternatively, use an API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys`;
     } else {
       contextualMessage = `AI Gateway authentication failed: No authentication provided.
 
-Provide either an API key or OIDC token.
-
-API key instructions:
-
-The token is expected to be provided via the 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.
+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.
 
-OIDC token instructions:
-
-The token is expected to be provided via the 'VERCEL_OIDC_TOKEN' environment variable. It expires every 12 hours.
-- make sure your Vercel project settings have OIDC enabled
-- if running locally with 'vercel dev', the token is automatically obtained and refreshed
-- if running locally with your own dev server, run 'vercel env pull' to fetch the token
-- in production/preview, the token is automatically obtained and refreshed`;
+Option 2 - OIDC token:
+Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the token.`;
     }
     return new _GatewayAuthenticationError({
       message: contextualMessage,
       statusCode,
-      cause
+      cause,
+      generationId
     });
   }
 };
@@ -150,9 +145,10 @@ var GatewayInvalidRequestError = class extends (_b3 = GatewayError, _a3 = symbol
   constructor({
     message = "Invalid request",
     statusCode = 400,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a3] = true;
     // used in isInstance
     this.name = name2;
@@ -172,9 +168,10 @@ var GatewayRateLimitError = class extends (_b4 = GatewayError, _a4 = symbol4, _b
   constructor({
     message = "Rate limit exceeded",
     statusCode = 429,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a4] = true;
     // used in isInstance
     this.name = name3;
@@ -187,21 +184,27 @@ 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");
 var name4 = "GatewayModelNotFoundError";
 var marker5 = `vercel.ai.gateway.error.${name4}`;
 var symbol5 = Symbol.for(marker5);
-var modelNotFoundParamSchema = import_v4.z.object({
-  modelId: import_v4.z.string()
-});
+var modelNotFoundParamSchema = (0, import_provider_utils.lazySchema)(
+  () => (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({
     message = "Model not found",
     statusCode = 404,
     modelId,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a5] = true;
     // used in isInstance
     this.name = name4;
@@ -222,9 +225,10 @@ var GatewayInternalServerError = class extends (_b6 = GatewayError, _a6 = symbol
   constructor({
     message = "Internal server error",
     statusCode = 500,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a6] = true;
     // used in isInstance
     this.name = name5;
@@ -246,9 +250,10 @@ var GatewayResponseError = class extends (_b7 = GatewayError, _a7 = symbol7, _b7
     statusCode = 502,
     response,
     validationError,
-    cause
+    cause,
+    generationId
   } = {}) {
-    super({ message, statusCode, cause });
+    super({ message, statusCode, cause, generationId });
     this[_a7] = true;
     // used in isInstance
     this.name = name6;
@@ -262,63 +267,99 @@ 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);
+  var _a8;
+  const parseResult = await (0, import_provider_utils2.safeValidateTypes)({
+    value: response,
+    schema: gatewayErrorResponseSchema
+  });
   if (!parseResult.success) {
+    const rawGenerationId = typeof response === "object" && response !== null && "generationId" in response ? response.generationId : void 0;
     return new GatewayResponseError({
       message: `Invalid error response format: ${defaultMessage}`,
       statusCode,
       response,
       validationError: parseResult.error,
-      cause
+      cause,
+      generationId: rawGenerationId
     });
   }
-  const validatedResponse = parseResult.data;
+  const validatedResponse = parseResult.value;
   const errorType = validatedResponse.error.type;
   const message = validatedResponse.error.message;
+  const generationId = (_a8 = validatedResponse.generationId) != null ? _a8 : void 0;
   switch (errorType) {
     case "authentication_error":
       return GatewayAuthenticationError.createContextualError({
         apiKeyProvided: authMethod === "api-key",
         oidcTokenProvided: authMethod === "oidc",
         statusCode,
-        cause
+        cause,
+        generationId
       });
     case "invalid_request_error":
-      return new GatewayInvalidRequestError({ message, statusCode, cause });
+      return new GatewayInvalidRequestError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
     case "rate_limit_exceeded":
-      return new GatewayRateLimitError({ message, statusCode, cause });
+      return new GatewayRateLimitError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
     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,
-        cause
+        modelId: modelResult.success ? modelResult.value.modelId : void 0,
+        cause,
+        generationId
       });
     }
     case "internal_server_error":
-      return new GatewayInternalServerError({ message, statusCode, cause });
+      return new GatewayInternalServerError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
     default:
-      return new GatewayInternalServerError({ message, statusCode, cause });
+      return new GatewayInternalServerError({
+        message,
+        statusCode,
+        cause,
+        generationId
+      });
   }
 }
-var gatewayErrorResponseSchema = 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 = (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()
+      }),
+      generationId: import_v42.z.string().nullish()
+    })
+  )
+);
 
 // src/errors/as-gateway-error.ts
 function asGatewayError(error, authMethod) {
@@ -361,20 +402,21 @@ function extractApiCallResponse(error) {
 
 // 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";
-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 = import_v43.z.union([
-  import_v43.z.literal("api-key"),
-  import_v43.z.literal("oidc")
-]);
+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")]))
+);
 
 // src/gateway-fetch-metadata.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
 var import_v44 = require("zod/v4");
 var GatewayFetchMetadata = class {
   constructor(config) {
@@ -382,13 +424,13 @@ var GatewayFetchMetadata = class {
   }
   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)({
+        failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)({
           errorSchema: import_v44.z.any(),
           errorToMessage: (data) => data
         }),
@@ -396,17 +438,19 @@ var GatewayFetchMetadata = class {
       });
       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)({
+        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
         }),
@@ -414,53 +458,62 @@ var GatewayFetchMetadata = class {
       });
       return value;
     } catch (error) {
-      throw asGatewayError(error);
+      throw await asGatewayError(error);
     }
   }
 };
-var gatewayLanguageModelSpecificationSchema = import_v44.z.object({
-  specificationVersion: import_v44.z.literal("v2"),
-  provider: import_v44.z.string(),
-  modelId: import_v44.z.string()
-});
-var gatewayLanguageModelPricingSchema = 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 } : {}
-}));
-var gatewayLanguageModelEntrySchema = import_v44.z.object({
-  id: import_v44.z.string(),
-  name: import_v44.z.string(),
-  description: import_v44.z.string().nullish(),
-  pricing: gatewayLanguageModelPricingSchema.nullish(),
-  specification: gatewayLanguageModelSpecificationSchema,
-  modelType: import_v44.z.enum(["language", "embedding", "image"]).nullish()
-});
-var gatewayFetchMetadataSchema = import_v44.z.object({
-  models: import_v44.z.array(gatewayLanguageModelEntrySchema)
-});
-var gatewayCreditsSchema = import_v44.z.object({
-  balance: import_v44.z.string(),
-  total_used: import_v44.z.string()
-}).transform(({ balance, total_used }) => ({
-  balance,
-  totalUsed: total_used
-}));
+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()
+          }).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("v3"),
+            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.lazySchema)(
+  () => (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 import_provider_utils5 = require("@ai-sdk/provider-utils");
 var import_v45 = require("zod/v4");
 var GatewayLanguageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v2";
+    this.specificationVersion = "v3";
     this.supportedUrls = { "*/*": [/.*/] };
   }
   get provider() {
@@ -476,23 +529,23 @@ 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)(import_v45.z.any()),
-        failedResponseHandler: (0, import_provider_utils2.createJsonErrorResponseHandler)({
+        successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(import_v45.z.any()),
+        failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
           errorSchema: import_v45.z.any(),
           errorToMessage: (data) => data
         }),
@@ -506,25 +559,25 @@ 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)(import_v45.z.any()),
-        failedResponseHandler: (0, import_provider_utils2.createJsonErrorResponseHandler)({
+        successfulResponseHandler: (0, import_provider_utils5.createEventSourceResponseHandler)(import_v45.z.any()),
+        failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)({
           errorSchema: import_v45.z.any(),
           errorToMessage: (data) => data
         }),
@@ -561,7 +614,7 @@ var GatewayLanguageModel = class {
         response: { headers: responseHeaders }
       };
     } catch (error) {
-      throw asGatewayError(error, parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
     }
   }
   isFilePart(part) {
@@ -595,7 +648,7 @@ var GatewayLanguageModel = class {
   }
   getModelConfigHeaders(modelId, streaming) {
     return {
-      "ai-language-model-specification-version": "2",
+      "ai-language-model-specification-version": "3",
       "ai-language-model-id": modelId,
       "ai-language-model-streaming": String(streaming)
     };
@@ -603,13 +656,13 @@ var GatewayLanguageModel = class {
 };
 
 // src/gateway-embedding-model.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
 var import_v46 = require("zod/v4");
 var GatewayEmbeddingModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v2";
+    this.specificationVersion = "v3";
     this.maxEmbeddingsPerCall = 2048;
     this.supportsParallelCalls = true;
   }
@@ -623,28 +676,28 @@ 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,
+          values,
           ...providerOptions ? { providerOptions } : {}
         },
-        successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+        successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(
           gatewayEmbeddingResponseSchema
         ),
-        failedResponseHandler: (0, import_provider_utils3.createJsonErrorResponseHandler)({
+        failedResponseHandler: (0, import_provider_utils6.createJsonErrorResponseHandler)({
           errorSchema: import_v46.z.any(),
           errorToMessage: (data) => data
         }),
@@ -655,10 +708,11 @@ var GatewayEmbeddingModel = class {
         embeddings: responseBody.embeddings,
         usage: (_a8 = responseBody.usage) != null ? _a8 : void 0,
         providerMetadata: responseBody.providerMetadata,
-        response: { headers: responseHeaders, body: rawValue }
+        response: { headers: responseHeaders, body: rawValue },
+        warnings: []
       };
     } catch (error) {
-      throw asGatewayError(error, parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
     }
   }
   getUrl() {
@@ -666,16 +720,227 @@ var GatewayEmbeddingModel = class {
   }
   getModelConfigHeaders() {
     return {
-      "ai-embedding-model-specification-version": "2",
+      "ai-embedding-model-specification-version": "3",
+      "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()
+    })
+  )
+);
+
+// src/gateway-image-model.ts
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
+var import_v47 = require("zod/v4");
+var GatewayImageModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    // Set a very large number to prevent client-side splitting of requests
+    this.maxImagesPerCall = Number.MAX_SAFE_INTEGER;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    files,
+    mask,
+    providerOptions,
+    headers,
+    abortSignal
+  }) {
+    var _a8;
+    const resolvedHeaders = await (0, import_provider_utils7.resolve)(this.config.headers());
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue
+      } = await (0, import_provider_utils7.postJsonToApi)({
+        url: this.getUrl(),
+        headers: (0, import_provider_utils7.combineHeaders)(
+          resolvedHeaders,
+          headers != null ? headers : {},
+          this.getModelConfigHeaders(),
+          await (0, import_provider_utils7.resolve)(this.config.o11yHeaders)
+        ),
+        body: {
+          prompt,
+          n,
+          ...size && { size },
+          ...aspectRatio && { aspectRatio },
+          ...seed && { seed },
+          ...providerOptions && { providerOptions },
+          ...files && {
+            files: files.map((file) => maybeEncodeImageFile(file))
+          },
+          ...mask && { mask: maybeEncodeImageFile(mask) }
+        },
+        successfulResponseHandler: (0, import_provider_utils7.createJsonResponseHandler)(
+          gatewayImageResponseSchema
+        ),
+        failedResponseHandler: (0, import_provider_utils7.createJsonErrorResponseHandler)({
+          errorSchema: import_v47.z.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        images: responseBody.images,
+        // Always base64 strings from server
+        warnings: (_a8 = responseBody.warnings) != null ? _a8 : [],
+        providerMetadata: responseBody.providerMetadata,
+        response: {
+          timestamp: /* @__PURE__ */ new Date(),
+          modelId: this.modelId,
+          headers: responseHeaders
+        }
+      };
+    } catch (error) {
+      throw asGatewayError(error, await parseAuthMethod(resolvedHeaders));
+    }
+  }
+  getUrl() {
+    return `${this.config.baseURL}/image-model`;
+  }
+  getModelConfigHeaders() {
+    return {
+      "ai-image-model-specification-version": "3",
       "ai-model-id": this.modelId
     };
   }
 };
-var gatewayEmbeddingResponseSchema = 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()
+function maybeEncodeImageFile(file) {
+  if (file.type === "file" && file.data instanceof Uint8Array) {
+    return {
+      ...file,
+      data: (0, import_provider_utils7.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 gatewayImageResponseSchema = import_v47.z.object({
+  images: import_v47.z.array(import_v47.z.string()),
+  // Always base64 strings over the wire
+  warnings: import_v47.z.array(
+    import_v47.z.object({
+      type: import_v47.z.literal("other"),
+      message: import_v47.z.string()
+    })
+  ).optional(),
+  providerMetadata: import_v47.z.record(import_v47.z.string(), providerMetadataEntrySchema).optional()
+});
+
+// src/tool/perplexity-search.ts
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
+var import_zod = require("zod");
+var perplexitySearchInputSchema = (0, import_provider_utils8.lazySchema)(
+  () => (0, import_provider_utils8.zodSchema)(
+    import_zod.z.object({
+      query: import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.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_zod.z.number().optional().describe(
+        "Maximum number of search results to return (1-20, default: 10)"
+      ),
+      max_tokens_per_page: import_zod.z.number().optional().describe(
+        "Maximum number of tokens to extract per search result page (256-2048, default: 2048)"
+      ),
+      max_tokens: import_zod.z.number().optional().describe(
+        "Maximum total tokens across all search results (default: 25000, max: 1000000)"
+      ),
+      country: import_zod.z.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_zod.z.array(import_zod.z.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_zod.z.array(import_zod.z.string()).optional().describe(
+        "List of ISO 639-1 language codes to filter results (max 10, lowercase). Examples: ['en', 'fr', 'de']"
+      ),
+      search_after_date: import_zod.z.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_zod.z.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_zod.z.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_zod.z.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_zod.z.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_utils8.lazySchema)(
+  () => (0, import_provider_utils8.zodSchema)(
+    import_zod.z.union([
+      // Success response
+      import_zod.z.object({
+        results: import_zod.z.array(
+          import_zod.z.object({
+            title: import_zod.z.string(),
+            url: import_zod.z.string(),
+            snippet: import_zod.z.string(),
+            date: import_zod.z.string().optional(),
+            lastUpdated: import_zod.z.string().optional()
+          })
+        ),
+        id: import_zod.z.string()
+      }),
+      // Error response
+      import_zod.z.object({
+        error: import_zod.z.enum([
+          "api_error",
+          "rate_limit",
+          "timeout",
+          "invalid_input",
+          "unknown"
+        ]),
+        statusCode: import_zod.z.number().optional(),
+        message: import_zod.z.string()
+      })
+    ])
+  )
+);
+var perplexitySearchToolFactory = (0, import_provider_utils8.createProviderToolFactoryWithOutputSchema)({
+  id: "gateway.perplexity_search",
+  inputSchema: perplexitySearchInputSchema,
+  outputSchema: perplexitySearchOutputSchema
 });
+var perplexitySearch = (config = {}) => perplexitySearchToolFactory(config);
+
+// src/gateway-tools.ts
+var gatewayTools = {
+  /**
+   * Search the web using Perplexity's Search API for real-time information,
+   * news, research papers, and articles.
+   *
+   * Provides ranked search results with advanced filtering options including
+   * domain, language, date range, and recency filters.
+   */
+  perplexitySearch
+};
 
 // src/vercel-environment.ts
 var import_oidc = require("@vercel/oidc");
@@ -686,10 +951,10 @@ async function getVercelRequestId() {
 }
 
 // src/gateway-provider.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_provider_utils10 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "0.0.0-02dba89b-20251009204516" : "0.0.0-test";
+var VERSION = true ? "0.0.0-4115c213-20260122152721" : "0.0.0-test";
 
 // src/gateway-provider.ts
 var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
@@ -699,11 +964,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_utils9.withoutTrailingSlash)(options.baseURL)) != null ? _b8 : "https://ai-gateway.vercel.sh/v3/ai";
   const getHeaders = async () => {
-    const auth = await getGatewayAuthToken(options);
-    if (auth) {
-      return (0, import_provider_utils5.withUserAgentSuffix)(
+    try {
+      const auth = await getGatewayAuthToken(options);
+      return (0, import_provider_utils10.withUserAgentSuffix)(
         {
           Authorization: `Bearer ${auth.token}`,
           "ai-gateway-protocol-version": AI_GATEWAY_PROTOCOL_VERSION,
@@ -712,23 +977,25 @@ function createGatewayProvider(options = {}) {
         },
         `ai-sdk/gateway/${VERSION}`
       );
+    } catch (error) {
+      throw GatewayAuthenticationError.createContextualError({
+        apiKeyProvided: false,
+        oidcTokenProvided: false,
+        statusCode: 401,
+        cause: error
+      });
     }
-    throw GatewayAuthenticationError.createContextualError({
-      apiKeyProvided: false,
-      oidcTokenProvided: false,
-      statusCode: 401
-    });
   };
   const createO11yHeaders = () => {
-    const deploymentId = (0, import_provider_utils4.loadOptionalSetting)({
+    const deploymentId = (0, import_provider_utils9.loadOptionalSetting)({
       settingValue: void 0,
       environmentVariableName: "VERCEL_DEPLOYMENT_ID"
     });
-    const environment = (0, import_provider_utils4.loadOptionalSetting)({
+    const environment = (0, import_provider_utils9.loadOptionalSetting)({
       settingValue: void 0,
       environmentVariableName: "VERCEL_ENV"
     });
-    const region = (0, import_provider_utils4.loadOptionalSetting)({
+    const region = (0, import_provider_utils9.loadOptionalSetting)({
       settingValue: void 0,
       environmentVariableName: "VERCEL_REGION"
     });
@@ -764,7 +1031,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;
@@ -775,7 +1045,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) {
@@ -786,13 +1059,20 @@ function createGatewayProvider(options = {}) {
     }
     return createLanguageModel(modelId);
   };
+  provider.specificationVersion = "v3";
   provider.getAvailableModels = getAvailableModels;
   provider.getCredits = getCredits;
   provider.imageModel = (modelId) => {
-    throw new import_provider2.NoSuchModelError({ modelId, modelType: "imageModel" });
+    return new GatewayImageModel(modelId, {
+      provider: "gateway",
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      o11yHeaders: createO11yHeaders()
+    });
   };
   provider.languageModel = createLanguageModel;
-  provider.textEmbeddingModel = (modelId) => {
+  const createEmbeddingModel = (modelId) => {
     return new GatewayEmbeddingModel(modelId, {
       provider: "gateway",
       baseURL,
@@ -801,11 +1081,14 @@ function createGatewayProvider(options = {}) {
       o11yHeaders: createO11yHeaders()
     });
   };
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.tools = gatewayTools;
   return provider;
 }
 var gateway = createGatewayProvider();
 async function getGatewayAuthToken(options) {
-  const apiKey = (0, import_provider_utils4.loadOptionalSetting)({
+  const apiKey = (0, import_provider_utils9.loadOptionalSetting)({
     settingValue: options.apiKey,
     environmentVariableName: "AI_GATEWAY_API_KEY"
   });
@@ -815,15 +1098,11 @@ async function getGatewayAuthToken(options) {
       authMethod: "api-key"
     };
   }
-  try {
-    const oidcToken = await (0, import_oidc2.getVercelOidcToken)();
-    return {
-      token: oidcToken,
-      authMethod: "oidc"
-    };
-  } catch (e) {
-    return null;
-  }
+  const oidcToken = await (0, import_oidc2.getVercelOidcToken)();
+  return {
+    token: oidcToken,
+    authMethod: "oidc"
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {