@ai-sdk/gateway 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/index.mjs

@@ -1,20 +1,332 @@
 // src/gateway-provider.ts
 import { NoSuchModelError } from "@ai-sdk/provider";
-import { loadOptionalSetting } from "@ai-sdk/provider-utils";
 import {
+  loadOptionalSetting,
   withoutTrailingSlash
 } from "@ai-sdk/provider-utils";
 
+// src/errors/as-gateway-error.ts
+import { APICallError } from "@ai-sdk/provider";
+
+// src/errors/create-gateway-error.ts
+import { z as z2 } from "zod";
+
+// src/errors/gateway-error.ts
+var marker = "vercel.ai.gateway.error";
+var symbol = Symbol.for(marker);
+var _a, _b;
+var GatewayError = class _GatewayError extends (_b = Error, _a = symbol, _b) {
+  constructor({
+    message,
+    statusCode = 500,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.statusCode = statusCode;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is a Gateway Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is a Gateway Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _GatewayError.hasMarker(error);
+  }
+  static hasMarker(error) {
+    return typeof error === "object" && error !== null && symbol in error && error[symbol] === true;
+  }
+};
+
+// src/errors/gateway-authentication-error.ts
+var name = "GatewayAuthenticationError";
+var marker2 = `vercel.ai.gateway.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2, _b2;
+var GatewayAuthenticationError = class extends (_b2 = GatewayError, _a2 = symbol2, _b2) {
+  constructor({
+    message = "Authentication failed",
+    statusCode = 401,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a2] = true;
+    // used in isInstance
+    this.name = name;
+    this.type = "authentication_error";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol2 in error;
+  }
+};
+
+// src/errors/gateway-invalid-request-error.ts
+var name2 = "GatewayInvalidRequestError";
+var marker3 = `vercel.ai.gateway.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3, _b3;
+var GatewayInvalidRequestError = class extends (_b3 = GatewayError, _a3 = symbol3, _b3) {
+  constructor({
+    message = "Invalid request",
+    statusCode = 400,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a3] = true;
+    // used in isInstance
+    this.name = name2;
+    this.type = "invalid_request_error";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol3 in error;
+  }
+};
+
+// src/errors/gateway-rate-limit-error.ts
+var name3 = "GatewayRateLimitError";
+var marker4 = `vercel.ai.gateway.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4, _b4;
+var GatewayRateLimitError = class extends (_b4 = GatewayError, _a4 = symbol4, _b4) {
+  constructor({
+    message = "Rate limit exceeded",
+    statusCode = 429,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a4] = true;
+    // used in isInstance
+    this.name = name3;
+    this.type = "rate_limit_exceeded";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol4 in error;
+  }
+};
+
+// src/errors/gateway-model-not-found-error.ts
+import { z } from "zod";
+var name4 = "GatewayModelNotFoundError";
+var marker5 = `vercel.ai.gateway.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var modelNotFoundParamSchema = z.object({
+  modelId: z.string()
+});
+var _a5, _b5;
+var GatewayModelNotFoundError = class extends (_b5 = GatewayError, _a5 = symbol5, _b5) {
+  constructor({
+    message = "Model not found",
+    statusCode = 404,
+    modelId,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a5] = true;
+    // used in isInstance
+    this.name = name4;
+    this.type = "model_not_found";
+    this.modelId = modelId;
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol5 in error;
+  }
+};
+
+// src/errors/gateway-internal-server-error.ts
+var name5 = "GatewayInternalServerError";
+var marker6 = `vercel.ai.gateway.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6, _b6;
+var GatewayInternalServerError = class extends (_b6 = GatewayError, _a6 = symbol6, _b6) {
+  constructor({
+    message = "Internal server error",
+    statusCode = 500,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a6] = true;
+    // used in isInstance
+    this.name = name5;
+    this.type = "internal_server_error";
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol6 in error;
+  }
+};
+
+// src/errors/gateway-response-error.ts
+var name6 = "GatewayResponseError";
+var marker7 = `vercel.ai.gateway.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7, _b7;
+var GatewayResponseError = class extends (_b7 = GatewayError, _a7 = symbol7, _b7) {
+  constructor({
+    message = "Invalid response from Gateway",
+    statusCode = 502,
+    response,
+    validationError,
+    cause
+  } = {}) {
+    super({ message, statusCode, cause });
+    this[_a7] = true;
+    // used in isInstance
+    this.name = name6;
+    this.type = "response_error";
+    this.response = response;
+    this.validationError = validationError;
+  }
+  static isInstance(error) {
+    return GatewayError.hasMarker(error) && symbol7 in error;
+  }
+};
+
+// src/errors/create-gateway-error.ts
+function createGatewayErrorFromResponse({
+  response,
+  statusCode,
+  defaultMessage = "Gateway request failed",
+  cause
+}) {
+  const parseResult = gatewayErrorResponseSchema.safeParse(response);
+  if (!parseResult.success) {
+    return new GatewayResponseError({
+      message: `Invalid error response format: ${defaultMessage}`,
+      statusCode,
+      response,
+      validationError: parseResult.error,
+      cause
+    });
+  }
+  const validatedResponse = parseResult.data;
+  const errorType = validatedResponse.error.type;
+  const message = validatedResponse.error.message;
+  switch (errorType) {
+    case "authentication_error":
+      return new GatewayAuthenticationError({ message, statusCode, cause });
+    case "invalid_request_error":
+      return new GatewayInvalidRequestError({ message, statusCode, cause });
+    case "rate_limit_exceeded":
+      return new GatewayRateLimitError({ message, statusCode, cause });
+    case "model_not_found": {
+      const modelResult = modelNotFoundParamSchema.safeParse(
+        validatedResponse.error.param
+      );
+      return new GatewayModelNotFoundError({
+        message,
+        statusCode,
+        modelId: modelResult.success ? modelResult.data.modelId : void 0,
+        cause
+      });
+    }
+    case "internal_server_error":
+      return new GatewayInternalServerError({ message, statusCode, cause });
+    default:
+      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()
+  })
+});
+
+// src/errors/as-gateway-error.ts
+function asGatewayError(error) {
+  var _a8;
+  if (GatewayError.isInstance(error)) {
+    return error;
+  }
+  if (APICallError.isInstance(error)) {
+    return createGatewayErrorFromResponse({
+      response: extractApiCallResponse(error),
+      statusCode: (_a8 = error.statusCode) != null ? _a8 : 500,
+      defaultMessage: "Gateway request failed",
+      cause: error
+    });
+  }
+  return createGatewayErrorFromResponse({
+    response: {},
+    statusCode: 500,
+    defaultMessage: error instanceof Error ? `Gateway request failed: ${error.message}` : "Unknown Gateway error",
+    cause: error
+  });
+}
+
+// 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-fetch-metadata.ts
+import {
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  getFromApi,
+  resolve
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod";
+var GatewayFetchMetadata = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async getAvailableModels() {
+    try {
+      const { value } = await getFromApi({
+        url: `${this.config.baseURL}/config`,
+        headers: await resolve(this.config.headers()),
+        successfulResponseHandler: createJsonResponseHandler(
+          gatewayFetchMetadataSchema
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z3.any(),
+          errorToMessage: (data) => data
+        }),
+        fetch: this.config.fetch
+      });
+      return value;
+    } catch (error) {
+      throw asGatewayError(error);
+    }
+  }
+};
+var gatewayLanguageModelSpecificationSchema = z3.object({
+  specificationVersion: z3.literal("v2"),
+  provider: z3.string(),
+  modelId: z3.string()
+});
+var gatewayLanguageModelEntrySchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  specification: gatewayLanguageModelSpecificationSchema
+});
+var gatewayFetchMetadataSchema = z3.object({
+  models: z3.array(gatewayLanguageModelEntrySchema)
+});
+
 // src/gateway-language-model.ts
 import {
   combineHeaders,
   createEventSourceResponseHandler,
-  createJsonErrorResponseHandler,
-  createJsonResponseHandler,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler2,
   postJsonToApi,
-  resolve
+  resolve as resolve2
 } from "@ai-sdk/provider-utils";
-import { z } from "zod";
+import { z as z4 } from "zod";
 var GatewayLanguageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -27,70 +339,78 @@ var GatewayLanguageModel = class {
   }
   async doGenerate(options) {
     const { abortSignal, ...body } = options;
-    const {
-      responseHeaders,
-      value: responseBody,
-      rawValue: rawResponse
-    } = await postJsonToApi({
-      url: this.getUrl(),
-      headers: combineHeaders(
-        await resolve(this.config.headers()),
-        options.headers,
-        this.getModelConfigHeaders(this.modelId, false),
-        this.config.o11yHeaders
-      ),
-      body: this.maybeEncodeFileParts(body),
-      successfulResponseHandler: createJsonResponseHandler(z.any()),
-      failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: z.any(),
-        errorToMessage: (data) => data
-      }),
-      ...abortSignal && { abortSignal },
-      fetch: this.config.fetch
-    });
-    return {
-      ...responseBody,
-      request: { body },
-      response: { headers: responseHeaders, body: rawResponse },
-      warnings: []
-    };
+    try {
+      const {
+        responseHeaders,
+        value: responseBody,
+        rawValue: rawResponse
+      } = await postJsonToApi({
+        url: this.getUrl(),
+        headers: combineHeaders(
+          await resolve2(this.config.headers()),
+          options.headers,
+          this.getModelConfigHeaders(this.modelId, false),
+          await resolve2(this.config.o11yHeaders)
+        ),
+        body: this.maybeEncodeFileParts(body),
+        successfulResponseHandler: createJsonResponseHandler2(z4.any()),
+        failedResponseHandler: createJsonErrorResponseHandler2({
+          errorSchema: z4.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        ...responseBody,
+        request: { body },
+        response: { headers: responseHeaders, body: rawResponse },
+        warnings: []
+      };
+    } catch (error) {
+      throw asGatewayError(error);
+    }
   }
   async doStream(options) {
     const { abortSignal, ...body } = options;
-    const { value: response, responseHeaders } = await postJsonToApi({
-      url: this.getUrl(),
-      headers: combineHeaders(
-        await resolve(this.config.headers()),
-        options.headers,
-        this.getModelConfigHeaders(this.modelId, true),
-        this.config.o11yHeaders
-      ),
-      body: this.maybeEncodeFileParts(body),
-      successfulResponseHandler: createEventSourceResponseHandler(z.any()),
-      failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: z.any(),
-        errorToMessage: (data) => data
-      }),
-      ...abortSignal && { abortSignal },
-      fetch: this.config.fetch
-    });
-    return {
-      stream: response.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            if (chunk.success) {
-              controller.enqueue(chunk.value);
-            } else {
-              controller.error(
-                chunk.error
-              );
+    try {
+      const { value: response, responseHeaders } = await postJsonToApi({
+        url: this.getUrl(),
+        headers: combineHeaders(
+          await resolve2(this.config.headers()),
+          options.headers,
+          this.getModelConfigHeaders(this.modelId, true),
+          await resolve2(this.config.o11yHeaders)
+        ),
+        body: this.maybeEncodeFileParts(body),
+        successfulResponseHandler: createEventSourceResponseHandler(z4.any()),
+        failedResponseHandler: createJsonErrorResponseHandler2({
+          errorSchema: z4.any(),
+          errorToMessage: (data) => data
+        }),
+        ...abortSignal && { abortSignal },
+        fetch: this.config.fetch
+      });
+      return {
+        stream: response.pipeThrough(
+          new TransformStream({
+            transform(chunk, controller) {
+              if (chunk.success) {
+                controller.enqueue(chunk.value);
+              } else {
+                controller.error(
+                  chunk.error
+                );
+              }
             }
-          }
-        })
-      ),
-      request: { body },
-      response: { headers: responseHeaders }
-    };
+          })
+        ),
+        request: { body },
+        response: { headers: responseHeaders }
+      };
+    } catch (error) {
+      throw asGatewayError(error);
+    }
   }
   isFilePart(part) {
     return part && typeof part === "object" && "type" in part && part.type === "file";
@@ -130,98 +450,50 @@ var GatewayLanguageModel = class {
   }
 };
 
-// src/get-vercel-oidc-token.ts
+// src/vercel-environment.ts
 async function getVercelOidcToken() {
-  var _a, _b;
-  const token = (_b = (_a = getContext().headers) == null ? void 0 : _a["x-vercel-oidc-token"]) != null ? _b : process.env.VERCEL_OIDC_TOKEN;
+  var _a8, _b8;
+  const token = (_b8 = (_a8 = getContext().headers) == null ? void 0 : _a8["x-vercel-oidc-token"]) != null ? _b8 : process.env.VERCEL_OIDC_TOKEN;
   if (!token) {
-    throw new Error(
-      `The 'x-vercel-oidc-token' header is missing from the request. Do you have the OIDC option enabled in the Vercel project settings?`
-    );
+    throw new GatewayAuthenticationError({
+      message: `Failed to get Vercel OIDC token for AI Gateway access.
+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 you're running locally with 'vercel dev' the token is automatically obtained and refreshed for you
+- if you're running locally with your own dev server script you can fetch/update the token by running 'vercel env pull'
+- in production or preview the token is automatically obtained and refreshed for you`,
+      statusCode: 401
+    });
   }
   return token;
 }
+async function getVercelRequestId() {
+  var _a8;
+  return (_a8 = getContext().headers) == null ? void 0 : _a8["x-vercel-id"];
+}
 var SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
 function getContext() {
-  var _a, _b, _c;
+  var _a8, _b8, _c;
   const fromSymbol = globalThis;
-  return (_c = (_b = (_a = fromSymbol[SYMBOL_FOR_REQ_CONTEXT]) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a)) != null ? _c : {};
+  return (_c = (_b8 = (_a8 = fromSymbol[SYMBOL_FOR_REQ_CONTEXT]) == null ? void 0 : _a8.get) == null ? void 0 : _b8.call(_a8)) != null ? _c : {};
 }
 
-// src/gateway-fetch-metadata.ts
-import {
-  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
-  createJsonResponseHandler as createJsonResponseHandler2,
-  getFromApi,
-  resolve as resolve2
-} from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod";
-var GatewayFetchMetadata = class {
-  constructor(config) {
-    this.config = config;
-  }
-  async getAvailableModels() {
-    const { value } = await getFromApi({
-      url: `${this.config.baseURL}/config`,
-      headers: await resolve2(this.config.headers()),
-      successfulResponseHandler: createJsonResponseHandler2(
-        gatewayFetchMetadataSchema
-      ),
-      failedResponseHandler: createJsonErrorResponseHandler2({
-        errorSchema: z2.any(),
-        errorToMessage: (data) => data
-      }),
-      fetch: this.config.fetch
-    });
-    return value;
-  }
-};
-var gatewayLanguageModelSpecificationSchema = z2.object({
-  specificationVersion: z2.literal("v2"),
-  provider: z2.string(),
-  modelId: z2.string()
-});
-var gatewayLanguageModelEntrySchema = z2.object({
-  id: z2.string(),
-  name: z2.string(),
-  specification: gatewayLanguageModelSpecificationSchema
-});
-var gatewayFetchMetadataSchema = z2.object({
-  models: z2.array(gatewayLanguageModelEntrySchema)
-});
-
 // src/gateway-provider.ts
 var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
 async function getGatewayAuthToken(options) {
-  var _a;
-  try {
-    return (_a = loadOptionalSetting({
-      settingValue: options.apiKey,
-      environmentVariableName: "AI_GATEWAY_API_KEY"
-    })) != null ? _a : await getVercelOidcToken();
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("'x-vercel-oidc-token' header is missing")) {
-      const enhancedError = new Error(
-        `Failed to get Vercel OIDC token for AI Gateway access.
-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 you're running locally with 'vercel dev' the token is automatically obtained and refreshed for you
-- if you're running locally with your own dev server script you can fetch/update the token by running 'vercel env pull'
-- in production or preview the token is automatically obtained and refreshed for you`
-      );
-      enhancedError.cause = error;
-      throw enhancedError;
-    }
-    throw error;
-  }
+  var _a8;
+  return (_a8 = loadOptionalSetting({
+    settingValue: options.apiKey,
+    environmentVariableName: "AI_GATEWAY_API_KEY"
+  })) != null ? _a8 : await getVercelOidcToken();
 }
 function createGatewayProvider(options = {}) {
-  var _a, _b;
+  var _a8, _b8;
   let pendingMetadata = null;
   let metadataCache = null;
-  const cacheRefreshMillis = (_a = options.metadataCacheRefreshMillis) != null ? _a : 1e3 * 60 * 5;
+  const cacheRefreshMillis = (_a8 = options.metadataCacheRefreshMillis) != null ? _a8 : 1e3 * 60 * 5;
   let lastFetchTime = 0;
-  const baseURL = (_b = withoutTrailingSlash(options.baseURL)) != null ? _b : "https://ai-gateway.vercel.sh/v1/ai";
+  const baseURL = (_b8 = withoutTrailingSlash(options.baseURL)) != null ? _b8 : "https://ai-gateway.vercel.sh/v1/ai";
   const getHeaders = async () => {
     return {
       Authorization: `Bearer ${await getGatewayAuthToken(options)}`,
@@ -232,7 +504,7 @@ function createGatewayProvider(options = {}) {
   const createLanguageModel = (modelId) => {
     const deploymentId = loadOptionalSetting({
       settingValue: void 0,
-      environmentVariableName: "DEPLOYMENT_ID"
+      environmentVariableName: "VERCEL_DEPLOYMENT_ID"
     });
     const environment = loadOptionalSetting({
       settingValue: void 0,
@@ -247,16 +519,20 @@ function createGatewayProvider(options = {}) {
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      o11yHeaders: {
-        ...deploymentId && { "ai-o11y-deployment-id": deploymentId },
-        ...environment && { "ai-o11y-environment": environment },
-        ...region && { "ai-o11y-region": region }
+      o11yHeaders: async () => {
+        const requestId = await getVercelRequestId();
+        return {
+          ...deploymentId && { "ai-o11y-deployment-id": deploymentId },
+          ...environment && { "ai-o11y-environment": environment },
+          ...region && { "ai-o11y-region": region },
+          ...requestId && { "ai-o11y-request-id": requestId }
+        };
       }
     });
   };
   const getAvailableModels = async () => {
-    var _a2, _b2, _c;
-    const now = (_c = (_b2 = (_a2 = options._internal) == null ? void 0 : _a2.currentDate) == null ? void 0 : _b2.call(_a2).getTime()) != null ? _c : Date.now();
+    var _a9, _b9, _c;
+    const now = (_c = (_b9 = (_a9 = options._internal) == null ? void 0 : _a9.currentDate) == null ? void 0 : _b9.call(_a9).getTime()) != null ? _c : Date.now();
     if (!pendingMetadata || now - lastFetchTime > cacheRefreshMillis) {
       lastFetchTime = now;
       pendingMetadata = new GatewayFetchMetadata({
@@ -266,6 +542,8 @@ function createGatewayProvider(options = {}) {
       }).getAvailableModels().then((metadata) => {
         metadataCache = metadata;
         return metadata;
+      }).catch((error) => {
+        throw asGatewayError(error);
       });
     }
     return metadataCache ? Promise.resolve(metadataCache) : pendingMetadata;
@@ -290,6 +568,13 @@ function createGatewayProvider(options = {}) {
 }
 var gateway = createGatewayProvider();
 export {
+  GatewayAuthenticationError,
+  GatewayError,
+  GatewayInternalServerError,
+  GatewayInvalidRequestError,
+  GatewayModelNotFoundError,
+  GatewayRateLimitError,
+  GatewayResponseError,
   createGatewayProvider,
   gateway
 };