@ai-sdk/gateway 0.0.0-02dba89b-20251009204516 → 0.0.0-64aae7dd-20260114144918

package/dist/index.mjs

@@ -1,5 +1,4 @@
 // src/gateway-provider.ts
-import { NoSuchModelError } from "@ai-sdk/provider";
 import {
   loadOptionalSetting,
   withoutTrailingSlash
@@ -71,35 +70,26 @@ var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b2
   }) {
     let contextualMessage;
     if (apiKeyProvided) {
-      contextualMessage = `AI Gateway authentication failed: Invalid API key provided.
+      contextualMessage = `AI Gateway authentication failed: Invalid API key.
 
-The token is expected to be provided via the 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.`;
+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.`;
     } 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,
@@ -155,12 +145,17 @@ var GatewayRateLimitError = class extends (_b4 = GatewayError, _a4 = symbol4, _b
 
 // src/errors/gateway-model-not-found-error.ts
 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 = z.object({
-  modelId: z.string()
-});
+var modelNotFoundParamSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      modelId: z.string()
+    })
+  )
+);
 var _a5, _b5;
 var GatewayModelNotFoundError = class extends (_b5 = GatewayError, _a5 = symbol5, _b5) {
   constructor({
@@ -230,14 +225,22 @@ var GatewayResponseError = class extends (_b7 = GatewayError, _a7 = symbol7, _b7
 };
 
 // src/errors/create-gateway-error.ts
-function createGatewayErrorFromResponse({
+import {
+  lazySchema as lazySchema2,
+  safeValidateTypes,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
+async function createGatewayErrorFromResponse({
   response,
   statusCode,
   defaultMessage = "Gateway request failed",
   cause,
   authMethod
 }) {
-  const parseResult = gatewayErrorResponseSchema.safeParse(response);
+  const parseResult = await safeValidateTypes({
+    value: response,
+    schema: gatewayErrorResponseSchema
+  });
   if (!parseResult.success) {
     return new GatewayResponseError({
       message: `Invalid error response format: ${defaultMessage}`,
@@ -247,7 +250,7 @@ function createGatewayErrorFromResponse({
       cause
     });
   }
-  const validatedResponse = parseResult.data;
+  const validatedResponse = parseResult.value;
   const errorType = validatedResponse.error.type;
   const message = validatedResponse.error.message;
   switch (errorType) {
@@ -263,13 +266,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 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
       });
     }
@@ -279,14 +283,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 = 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()
+      })
+    })
+  )
+);
 
 // src/errors/as-gateway-error.ts
 function asGatewayError(error, authMethod) {
@@ -329,24 +337,31 @@ function extractApiCallResponse(error) {
 
 // src/errors/parse-auth-method.ts
 import { z as z3 } from "zod/v4";
+import {
+  lazySchema as lazySchema3,
+  safeValidateTypes as safeValidateTypes2,
+  zodSchema as zodSchema3
+} from "@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 safeValidateTypes2({
+    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 = lazySchema3(
+  () => zodSchema3(z3.union([z3.literal("api-key"), z3.literal("oidc")]))
+);
 
 // src/gateway-fetch-metadata.ts
 import {
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
   getFromApi,
-  resolve
+  lazySchema as lazySchema4,
+  resolve,
+  zodSchema as zodSchema4
 } from "@ai-sdk/provider-utils";
 import { z as z4 } from "zod/v4";
 var GatewayFetchMetadata = class {
@@ -359,7 +374,7 @@ var GatewayFetchMetadata = class {
         url: `${this.config.baseURL}/config`,
         headers: await resolve(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(
-          gatewayFetchMetadataSchema
+          gatewayAvailableModelsResponseSchema
         ),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: z4.any(),
@@ -369,7 +384,7 @@ var GatewayFetchMetadata = class {
       });
       return value;
     } catch (error) {
-      throw asGatewayError(error);
+      throw await asGatewayError(error);
     }
   }
   async getCredits() {
@@ -378,7 +393,9 @@ var GatewayFetchMetadata = class {
       const { value } = await getFromApi({
         url: `${baseUrl.origin}/v1/credits`,
         headers: await resolve(this.config.headers()),
-        successfulResponseHandler: createJsonResponseHandler(gatewayCreditsSchema),
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewayCreditsResponseSchema
+        ),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: z4.any(),
           errorToMessage: (data) => data
@@ -387,44 +404,53 @@ var GatewayFetchMetadata = class {
       });
       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 = 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,
+              output,
+              ...input_cache_read ? { cachedInputTokens: input_cache_read } : {},
+              ...input_cache_write ? { cacheCreationInputTokens: input_cache_write } : {}
+            })
+          ).nullish(),
+          specification: z4.object({
+            specificationVersion: z4.literal("v3"),
+            provider: z4.string(),
+            modelId: z4.string()
+          }),
+          modelType: z4.enum(["language", "embedding", "image"]).nullish()
+        })
+      )
+    })
+  )
+);
+var gatewayCreditsResponseSchema = lazySchema4(
+  () => zodSchema4(
+    z4.object({
+      balance: z4.string(),
+      total_used: z4.string()
+    }).transform(({ balance, total_used }) => ({
+      balance,
+      totalUsed: total_used
+    }))
+  )
+);
 
 // src/gateway-language-model.ts
 import {
@@ -440,7 +466,7 @@ var GatewayLanguageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v2";
+    this.specificationVersion = "v3";
     this.supportedUrls = { "*/*": [/.*/] };
   }
   get provider() {
@@ -486,7 +512,7 @@ var GatewayLanguageModel = class {
         warnings
       };
     } catch (error) {
-      throw asGatewayError(error, parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
     }
   }
   async doStream(options) {
@@ -541,7 +567,7 @@ var GatewayLanguageModel = class {
         response: { headers: responseHeaders }
       };
     } catch (error) {
-      throw asGatewayError(error, parseAuthMethod(resolvedHeaders));
+      throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders));
     }
   }
   isFilePart(part) {
@@ -575,7 +601,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)
     };
@@ -585,17 +611,19 @@ var GatewayLanguageModel = class {
 // src/gateway-embedding-model.ts
 import {
   combineHeaders as combineHeaders2,
-  createJsonResponseHandler as createJsonResponseHandler3,
   createJsonErrorResponseHandler as createJsonErrorResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  lazySchema as lazySchema5,
   postJsonToApi as postJsonToApi2,
-  resolve as resolve3
+  resolve as resolve3,
+  zodSchema as zodSchema5
 } from "@ai-sdk/provider-utils";
 import { z as z6 } from "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;
   }
@@ -624,7 +652,7 @@ var GatewayEmbeddingModel = class {
           await resolve3(this.config.o11yHeaders)
         ),
         body: {
-          input: values.length === 1 ? values[0] : values,
+          values,
           ...providerOptions ? { providerOptions } : {}
         },
         successfulResponseHandler: createJsonResponseHandler3(
@@ -641,10 +669,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() {
@@ -652,16 +681,238 @@ var GatewayEmbeddingModel = class {
   }
   getModelConfigHeaders() {
     return {
-      "ai-embedding-model-specification-version": "2",
+      "ai-embedding-model-specification-version": "3",
+      "ai-model-id": this.modelId
+    };
+  }
+};
+var gatewayEmbeddingResponseSchema = lazySchema5(
+  () => zodSchema5(
+    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()
+    })
+  )
+);
+
+// src/gateway-image-model.ts
+import {
+  combineHeaders as combineHeaders3,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler4,
+  postJsonToApi as postJsonToApi3,
+  resolve as resolve4
+} from "@ai-sdk/provider-utils";
+import { z as z7 } from "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 resolve4(this.config.headers());
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue
+      } = await postJsonToApi3({
+        url: this.getUrl(),
+        headers: combineHeaders3(
+          resolvedHeaders,
+          headers != null ? headers : {},
+          this.getModelConfigHeaders(),
+          await resolve4(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: createJsonResponseHandler4(
+          gatewayImageResponseSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler4({
+          errorSchema: z7.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 = 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()
+function maybeEncodeImageFile(file) {
+  if (file.type === "file" && file.data instanceof Uint8Array) {
+    return {
+      ...file,
+      data: convertUint8ArrayToBase64(file.data)
+    };
+  }
+  return file;
+}
+var providerMetadataEntrySchema = z7.object({
+  images: z7.array(z7.unknown()).optional()
+}).catchall(z7.unknown());
+var gatewayImageResponseSchema = z7.object({
+  images: z7.array(z7.string()),
+  // Always base64 strings over the wire
+  warnings: z7.array(
+    z7.object({
+      type: z7.literal("other"),
+      message: z7.string()
+    })
+  ).optional(),
+  providerMetadata: z7.record(z7.string(), providerMetadataEntrySchema).optional()
+});
+
+// src/tool/perplexity-search.ts
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema as lazySchema6,
+  zodSchema as zodSchema6
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod";
+var perplexitySearchInputSchema = lazySchema6(
+  () => zodSchema6(
+    z8.object({
+      query: z8.union([z8.string(), z8.array(z8.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: z8.number().optional().describe(
+        "Maximum number of search results to return (1-20, default: 10)"
+      ),
+      max_tokens_per_page: z8.number().optional().describe(
+        "Maximum number of tokens to extract per search result page (256-2048, default: 2048)"
+      ),
+      max_tokens: z8.number().optional().describe(
+        "Maximum total tokens across all search results (default: 25000, max: 1000000)"
+      ),
+      country: z8.string().optional().describe(
+        "Two-letter ISO 3166-1 alpha-2 country code for regional search results (e.g., 'US', 'GB', 'FR')"
+      ),
+      search_domain_filter: z8.array(z8.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: z8.array(z8.string()).optional().describe(
+        "List of ISO 639-1 language codes to filter results (max 10, lowercase). Examples: ['en', 'fr', 'de']"
+      ),
+      search_after_date: z8.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: z8.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: z8.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: z8.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: z8.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 = lazySchema6(
+  () => zodSchema6(
+    z8.union([
+      // Success response
+      z8.object({
+        results: z8.array(
+          z8.object({
+            title: z8.string(),
+            url: z8.string(),
+            snippet: z8.string(),
+            date: z8.string().optional(),
+            lastUpdated: z8.string().optional()
+          })
+        ),
+        id: z8.string()
+      }),
+      // Error response
+      z8.object({
+        error: z8.enum([
+          "api_error",
+          "rate_limit",
+          "timeout",
+          "invalid_input",
+          "unknown"
+        ]),
+        statusCode: z8.number().optional(),
+        message: z8.string()
+      })
+    ])
+  )
+);
+var perplexitySearchToolFactory = 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
 import { getContext } from "@vercel/oidc";
@@ -675,7 +926,7 @@ async function getVercelRequestId() {
 import { withUserAgentSuffix } from "@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-64aae7dd-20260114144918" : "0.0.0-test";
 
 // src/gateway-provider.ts
 var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
@@ -685,10 +936,10 @@ function createGatewayProvider(options = {}) {
   let metadataCache = null;
   const cacheRefreshMillis = (_a8 = options.metadataCacheRefreshMillis) != null ? _a8 : 1e3 * 60 * 5;
   let lastFetchTime = 0;
-  const baseURL = (_b8 = withoutTrailingSlash(options.baseURL)) != null ? _b8 : "https://ai-gateway.vercel.sh/v1/ai";
+  const baseURL = (_b8 = withoutTrailingSlash(options.baseURL)) != null ? _b8 : "https://ai-gateway.vercel.sh/v3/ai";
   const getHeaders = async () => {
-    const auth = await getGatewayAuthToken(options);
-    if (auth) {
+    try {
+      const auth = await getGatewayAuthToken(options);
       return withUserAgentSuffix(
         {
           Authorization: `Bearer ${auth.token}`,
@@ -698,12 +949,14 @@ 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 = loadOptionalSetting({
@@ -750,7 +1003,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;
@@ -761,7 +1017,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) {
@@ -772,13 +1031,20 @@ function createGatewayProvider(options = {}) {
     }
     return createLanguageModel(modelId);
   };
+  provider.specificationVersion = "v3";
   provider.getAvailableModels = getAvailableModels;
   provider.getCredits = getCredits;
   provider.imageModel = (modelId) => {
-    throw new 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,
@@ -787,6 +1053,9 @@ function createGatewayProvider(options = {}) {
       o11yHeaders: createO11yHeaders()
     });
   };
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.tools = gatewayTools;
   return provider;
 }
 var gateway = createGatewayProvider();
@@ -801,15 +1070,11 @@ async function getGatewayAuthToken(options) {
       authMethod: "api-key"
     };
   }
-  try {
-    const oidcToken = await getVercelOidcToken();
-    return {
-      token: oidcToken,
-      authMethod: "oidc"
-    };
-  } catch (e) {
-    return null;
-  }
+  const oidcToken = await getVercelOidcToken();
+  return {
+    token: oidcToken,
+    authMethod: "oidc"
+  };
 }
 export {
   GatewayAuthenticationError,