@macpaw/ai-sdk 0.1.0

package/dist/gateway-errors-DdgDIyQw.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Configuration types and resolver for the AI Gateway SDK.
+ *
+ * GatewayProviderSettings is the public API — 8 fields.
+ * ResolvedConfig is the internal resolved form used by the request pipeline.
+ */
+/**
+ * Supported gateway environments.
+ * Only 'production' is exposed — non-production setups use a direct `baseURL`
+ * instead, keeping env-specific URL management out of this library.
+ */
+type Environment = 'production';
+interface RetryConfig {
+    /** Max number of attempts (including first). Default 3. */
+    maxAttempts?: number;
+    /** Initial delay in ms. Default 1000. */
+    initialDelayMs?: number;
+    /** Max delay in ms. Default 30000. */
+    maxDelayMs?: number;
+    /** Retry only on these status codes (and network errors). Default: 429, 5xx. */
+    retryableStatuses?: number[];
+}
+interface RequestConfig {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: RequestInit['body'];
+    signal?: AbortSignal | undefined;
+}
+type Middleware = (config: RequestConfig, next: (config: RequestConfig) => Promise<Response>) => Promise<Response>;
+/**
+ * Configuration for AI Gateway providers and NestJS module.
+ *
+ * Exactly 8 fields — covers auth, routing, request behaviour and middleware.
+ */
+interface GatewayProviderSettings {
+    /** Gateway base URL. Required if env is not set. */
+    baseURL?: string;
+    /** 'production' uses the default MacPaw Gateway URL. */
+    env?: Environment;
+    /**
+     * Returns Bearer token for auth.
+     * Called with `forceRefresh=true` after 401 — provide a fresh token.
+     */
+    getAuthToken: (forceRefresh?: boolean) => Promise<string | null>;
+    /** Extra headers sent with every request. Do not set Authorization here. */
+    headers?: Record<string, string>;
+    /** Retry policy. Set to false to disable. */
+    retry?: RetryConfig | false;
+    /** Request timeout in ms. Default: 60000. */
+    timeout?: number;
+    /** Request interceptors. Run in order before each request. */
+    middleware?: Middleware[];
+    /**
+     * Custom fetch implementation.
+     * Use for testing or low-level request customization.
+     */
+    fetch?: typeof fetch;
+}
+
+/**
+ * Error types for the AI Gateway SDK.
+ *
+ * Combines error classes, API codes, and response shapes in one place.
+ * parseErrorResponse throws the SPECIFIC subclass (AuthError, CreditsError, etc.)
+ * so that `instanceof` checks work correctly in consumer code.
+ */
+type ObjectValues<T> = T[keyof T];
+/** Raw error codes returned by the AI Gateway HTTP API. */
+declare const GatewayApiCode: {
+    readonly BadRequest: "BAD_REQUEST";
+    readonly Unauthorized: "UNAUTHORIZED";
+    readonly InsufficientCredits: "INSUFFICIENT_CREDITS";
+    readonly Forbidden: "FORBIDDEN";
+    readonly Validation: "VALIDATION";
+    readonly RateLimitExceeded: "RATE_LIMIT_EXCEEDED";
+    readonly InternalServerError: "INTERNAL_SERVER_ERROR";
+    readonly ServiceUnavailable: "SERVICE_UNAVAILABLE";
+    readonly Timeout: "TIMEOUT";
+    readonly NotFound: "NOT_FOUND";
+    readonly Conflict: "CONFLICT";
+};
+type GatewayApiCode = ObjectValues<typeof GatewayApiCode>;
+/** Normalized error codes for app handling. */
+declare const ErrorCode: {
+    readonly AuthRequired: "AUTH_REQUIRED";
+    readonly InsufficientCredits: "INSUFFICIENT_CREDITS";
+    readonly SubscriptionExpired: "SUBSCRIPTION_EXPIRED";
+    readonly ModelNotAllowed: "MODEL_NOT_ALLOWED";
+    readonly RateLimited: "RATE_LIMITED";
+    readonly BadRequest: "BAD_REQUEST";
+    readonly Validation: "VALIDATION";
+    readonly Forbidden: "FORBIDDEN";
+    readonly InternalServerError: "INTERNAL_SERVER_ERROR";
+    readonly ServiceUnavailable: "SERVICE_UNAVAILABLE";
+    readonly Timeout: "TIMEOUT";
+    readonly NotFound: "NOT_FOUND";
+    readonly Conflict: "CONFLICT";
+};
+type ErrorCode = ObjectValues<typeof ErrorCode>;
+interface GatewayApiErrorItem {
+    target?: string;
+    property?: string;
+    constraints?: string[];
+    message?: string;
+    metadata?: Record<string, unknown>;
+}
+interface GatewayApiErrorResponse {
+    statusCode: number;
+    message: string;
+    timestamp: string;
+    code: GatewayApiCode;
+    path?: string;
+    errors?: GatewayApiErrorItem[];
+    request_id?: string;
+}
+interface OpenAIErrorResponse {
+    error: {
+        message: string;
+        type?: string | null;
+        code?: string | null;
+        param?: string | null;
+    };
+    request_id?: string;
+}
+interface NormalizedErrorMetadata {
+    paymentUrl?: string;
+    /** Suggested delay before retrying, in seconds (from server's `Retry-After`). */
+    retryAfter?: number;
+    requestId?: string;
+    path?: string;
+    timestamp?: string;
+    errors?: GatewayApiErrorItem[];
+}
+declare class AIGatewayError extends Error {
+    readonly code: ErrorCode;
+    readonly statusCode: number;
+    readonly metadata: NormalizedErrorMetadata;
+    constructor(message: string, code: ErrorCode, statusCode: number, metadata?: NormalizedErrorMetadata, options?: {
+        cause?: unknown;
+    });
+    get paymentUrl(): string | undefined;
+    /** Suggested delay before retrying, in seconds. `undefined` if not provided by the server. */
+    get retryAfter(): number | undefined;
+    get requestId(): string | undefined;
+    toJSON(): Record<string, unknown>;
+}
+declare class AuthError extends AIGatewayError {
+    constructor(message: string, statusCode: number, metadata?: NormalizedErrorMetadata, options?: {
+        cause?: unknown;
+    });
+}
+declare class CreditsError extends AIGatewayError {
+    constructor(message: string, statusCode: number, code: typeof ErrorCode.InsufficientCredits | typeof ErrorCode.SubscriptionExpired, metadata?: NormalizedErrorMetadata, options?: {
+        cause?: unknown;
+    });
+}
+declare class RateLimitError extends AIGatewayError {
+    constructor(message: string, statusCode: number, metadata?: NormalizedErrorMetadata, options?: {
+        cause?: unknown;
+    });
+}
+declare class ModelNotAllowedError extends AIGatewayError {
+    constructor(message: string, statusCode: number, metadata?: NormalizedErrorMetadata, options?: {
+        cause?: unknown;
+    });
+}
+declare class GatewayValidationError extends AIGatewayError {
+    constructor(message: string, statusCode: number, metadata?: NormalizedErrorMetadata, options?: {
+        cause?: unknown;
+    });
+}
+/** Type guard: returns true if the value is an AIGatewayError (or any subclass). */
+declare function isAIGatewayError(value: unknown): value is AIGatewayError;
+/**
+ * Parse error response body and throw appropriate AIGatewayError subclass.
+ * Handles both Gateway API format and OpenAI proxy format.
+ */
+declare function parseErrorResponse(statusCode: number, body: unknown): never;
+
+export { AIGatewayError as A, CreditsError as C, ErrorCode as E, type GatewayProviderSettings as G, type Middleware as M, type NormalizedErrorMetadata as N, type OpenAIErrorResponse as O, RateLimitError as R, AuthError as a, GatewayApiCode as b, type GatewayApiErrorItem as c, type GatewayApiErrorResponse as d, GatewayValidationError as e, ModelNotAllowedError as f, type RetryConfig as g, isAIGatewayError as i, parseErrorResponse as p };

package/dist/index.cjs

@@ -0,0 +1,483 @@
+'use strict';
+
+var chunkN26BDEG5_cjs = require('./chunk-N26BDEG5.cjs');
+var openai = require('@ai-sdk/openai');
+
+// src/gateway-config.ts
+var DEFAULT_RETRY = {
+  maxAttempts: 3,
+  initialDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  retryableStatuses: [429, 500, 502, 503, 504]
+};
+function normalizeRetryConfig(merged) {
+  const n = Math.floor(Number(merged.maxAttempts));
+  const maxAttempts = Number.isFinite(n) && n >= 1 ? n : DEFAULT_RETRY.maxAttempts;
+  return { ...merged, maxAttempts };
+}
+function resolveConfig(config) {
+  return {
+    baseURL: config.baseURL,
+    getAuthToken: config.getAuthToken,
+    retry: config.retry === false ? false : normalizeRetryConfig({ ...DEFAULT_RETRY, ...config.retry }),
+    middleware: [...config.middleware ?? []],
+    headers: config.headers,
+    timeout: config.timeout ?? 6e4,
+    fetchImpl: config.fetch
+  };
+}
+var DEFAULT_BASE_URLS = {
+  production: "https://api.macpaw.com/ai"
+};
+function resolveGatewayBaseURL(baseURL, env, consumerName) {
+  const resolved = baseURL ?? (env ? DEFAULT_BASE_URLS[env] : void 0);
+  if (!resolved) {
+    throw new Error(
+      `${consumerName} requires baseURL or env (production). For non-production environments, pass baseURL directly.`
+    );
+  }
+  return resolved;
+}
+
+// src/gateway-retry.ts
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      },
+      { once: true }
+    );
+  });
+}
+function isRetryableStatus(status, retryableStatuses) {
+  return retryableStatuses.includes(status);
+}
+function addJitter(delayMs) {
+  const jitter = delayMs * 0.25 * Math.random();
+  return delayMs + jitter;
+}
+async function withRetry(fn, options) {
+  const { maxAttempts, initialDelayMs, maxDelayMs, retryableStatuses } = options.retryConfig;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt === maxAttempts) break;
+      const status = err?.statusCode;
+      const isRetryable = status != null ? isRetryableStatus(status, retryableStatuses) : options.isNetworkError?.(err) ?? false;
+      if (!isRetryable) throw err;
+      const retryAfterSeconds = err?.retryAfter;
+      let backoff;
+      if (retryAfterSeconds != null && retryAfterSeconds > 0) {
+        backoff = retryAfterSeconds * 1e3;
+      } else {
+        backoff = addJitter(Math.min(initialDelayMs * Math.pow(2, attempt - 1), maxDelayMs));
+      }
+      await delay(backoff, options.signal);
+    }
+  }
+  throw lastError;
+}
+
+// src/gateway-request.ts
+function anySignal(signals) {
+  const any = AbortSignal.any;
+  if (typeof any === "function") {
+    return any(signals);
+  }
+  const controller = new AbortController();
+  const handlers = [];
+  function cleanup() {
+    for (const [sig, handler] of handlers) sig.removeEventListener("abort", handler);
+    handlers.length = 0;
+  }
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+    const handler = () => {
+      cleanup();
+      controller.abort(signal.reason);
+    };
+    handlers.push([signal, handler]);
+    signal.addEventListener("abort", handler, { once: true });
+  }
+  controller.signal.addEventListener("abort", cleanup, { once: true });
+  return controller.signal;
+}
+var _counter = 0;
+function generateRequestId(prefix = "sdk") {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return `${prefix}-${globalThis.crypto.randomUUID()}`;
+  }
+  const timestamp = Date.now().toString(36);
+  const count = (_counter++).toString(36);
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${prefix}-${timestamp}-${count}-${random}`;
+}
+function hasHeaderCaseInsensitive(headers, name) {
+  const lower = name.toLowerCase();
+  return Object.keys(headers).some((k) => k.toLowerCase() === lower);
+}
+function shouldAutoSetJsonContentType(body, headers) {
+  if (body == null || hasHeaderCaseInsensitive(headers, "content-type")) return false;
+  const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+  const isBlob = typeof Blob !== "undefined" && body instanceof Blob;
+  return !isFormData && !isBlob;
+}
+var NODE_NETWORK_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENOTFOUND",
+  "EPIPE",
+  "ETIMEDOUT",
+  "ENETUNREACH",
+  "EAI_AGAIN",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+var FETCH_NETWORK_TYPEERROR_HINTS = [
+  "failed to fetch",
+  "fetch failed",
+  "load failed",
+  "networkerror",
+  "network error when attempting to fetch"
+];
+function hasRetryableNodeErrorCode(err) {
+  let cur = err;
+  for (let depth = 0; depth < 5 && cur != null; depth++) {
+    const code = cur?.code;
+    if (typeof code === "string" && NODE_NETWORK_CODES.has(code)) return true;
+    cur = cur instanceof Error && cur.cause !== void 0 ? cur.cause : void 0;
+  }
+  return false;
+}
+function isFetchFailureTypeError(err) {
+  if (!(err instanceof TypeError)) return false;
+  const msg = String(err.message).toLowerCase();
+  return FETCH_NETWORK_TYPEERROR_HINTS.some((hint) => msg.includes(hint));
+}
+function isNetworkError(err) {
+  return hasRetryableNodeErrorCode(err) || isFetchFailureTypeError(err);
+}
+async function executeFetch(fetchImpl, requestConfig) {
+  const impl = fetchImpl ?? globalThis.fetch;
+  if (typeof impl === "undefined") {
+    throw new Error(
+      "@macpaw/ai-sdk requires a global `fetch` implementation. Use Node.js 18+ or install a polyfill like `undici`."
+    );
+  }
+  return impl(requestConfig.url, {
+    method: requestConfig.method,
+    headers: requestConfig.headers,
+    body: requestConfig.body,
+    signal: requestConfig.signal
+  });
+}
+async function executeRequestPipeline(config, request, behavior) {
+  const b = {
+    includeConfigHeaders: behavior?.includeConfigHeaders ?? true,
+    includeAuth: behavior?.includeAuth ?? true,
+    includeRequestId: behavior?.includeRequestId ?? true,
+    normalizeErrors: behavior?.normalizeErrors ?? true,
+    allowAuthRetry: behavior?.allowAuthRetry ?? true,
+    requestIdPrefix: behavior?.requestIdPrefix
+  };
+  return executeWithAuth(config, request, b, false);
+}
+async function executeWithAuth(config, request, behavior, isTokenRetry) {
+  try {
+    return await executeRequest(config, request, behavior, isTokenRetry);
+  } catch (err) {
+    if (behavior.allowAuthRetry && !isTokenRetry && err instanceof chunkN26BDEG5_cjs.AuthError) {
+      if (typeof ReadableStream !== "undefined" && request.body instanceof ReadableStream) {
+        throw err;
+      }
+      return executeWithAuth(config, request, behavior, true);
+    }
+    throw err;
+  }
+}
+async function executeRequest(config, request, behavior, forceRefreshToken) {
+  const headers = {
+    ...behavior.includeConfigHeaders ? config.headers : void 0,
+    ...request.headers
+  };
+  if (shouldAutoSetJsonContentType(request.body, headers)) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (behavior.includeRequestId && !hasHeaderCaseInsensitive(headers, "x-request-id")) {
+    headers["X-Request-ID"] = generateRequestId(behavior.requestIdPrefix);
+  }
+  const timeoutMs = config.timeout;
+  const userSignal = request.signal;
+  async function doRequest() {
+    const timeoutController = new AbortController();
+    const timeoutId = setTimeout(
+      () => timeoutController.abort(new Error(`Request timed out after ${timeoutMs}ms`)),
+      timeoutMs
+    );
+    const signal = userSignal ? anySignal([userSignal, timeoutController.signal]) : timeoutController.signal;
+    const requestConfig = {
+      url: request.url,
+      method: request.method,
+      headers: { ...headers },
+      body: request.body,
+      signal
+    };
+    const { middleware } = config;
+    let index = 0;
+    const next = async (currentRequest) => {
+      if (index < middleware.length) {
+        const middlewareItem = middleware[index++];
+        return middlewareItem(currentRequest, next);
+      }
+      const finalHeaders = { ...currentRequest.headers };
+      if (behavior.includeAuth) {
+        const token = await config.getAuthToken(forceRefreshToken);
+        if (token) {
+          finalHeaders.Authorization = `Bearer ${token}`;
+        } else {
+          for (const key of Object.keys(finalHeaders)) {
+            if (key.toLowerCase() === "authorization") delete finalHeaders[key];
+          }
+        }
+      }
+      return executeFetch(config.fetchImpl, { ...currentRequest, headers: finalHeaders });
+    };
+    try {
+      const response = await next(requestConfig);
+      if (!response.ok) {
+        const retryableStatuses = config.retry !== false ? config.retry.retryableStatuses : [];
+        const isTransportCritical = behavior.allowAuthRetry && response.status === 401 || config.retry !== false && retryableStatuses.includes(response.status);
+        if (behavior.normalizeErrors || isTransportCritical) {
+          await chunkN26BDEG5_cjs.parseErrorResponseFromResponse(response);
+        }
+      }
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  if (config.retry) {
+    return withRetry(doRequest, {
+      retryConfig: config.retry,
+      signal: userSignal,
+      isNetworkError
+    });
+  }
+  return doRequest();
+}
+
+// src/gateway-fetch.ts
+function resolveRequestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+function stripPlaceholderAuthorization(headers, placeholder) {
+  const auth = headers.get("authorization");
+  if (auth === `Bearer ${placeholder}`) {
+    headers.delete("authorization");
+  }
+}
+function headersToRecord(headers) {
+  const record = {};
+  for (const [key, value] of headers.entries()) {
+    record[key] = value;
+  }
+  return record;
+}
+function joinBaseUrl(baseURL, path) {
+  return `${baseURL}${path.startsWith("/") ? "" : "/"}${path}`;
+}
+function isGatewayUrl(url, gatewayBaseUrl) {
+  const gatewayPath = gatewayBaseUrl.pathname.replace(/\/$/, "");
+  const requestPath = url.pathname.replace(/\/$/, "");
+  return url.origin === gatewayBaseUrl.origin && (requestPath === gatewayPath || requestPath.startsWith(`${gatewayPath}/`));
+}
+var GATEWAY_PLACEHOLDER_API_KEY = "ai-gateway-auth-via-fetch";
+function createGatewayFetch(options) {
+  const { baseURL, normalizeErrors = true } = options;
+  const base = baseURL.replace(/\/$/, "");
+  const gatewayBaseUrl = new URL(base);
+  const resolvedConfig = resolveConfig({ ...options, baseURL: base });
+  return async function gatewayFetch(input, init) {
+    const rawUrl = resolveRequestUrl(input);
+    const isAbsolute = rawUrl.startsWith("http://") || rawUrl.startsWith("https://");
+    const resolvedUrl = new URL(isAbsolute ? rawUrl : joinBaseUrl(base, rawUrl));
+    const isGatewayRequest = isGatewayUrl(resolvedUrl, gatewayBaseUrl);
+    const request = typeof Request !== "undefined" && input instanceof Request ? input : void 0;
+    const requestClone = request?.clone();
+    const headers = new Headers(requestClone?.headers);
+    if (init?.headers) {
+      for (const [key, value] of new Headers(init.headers).entries()) {
+        headers.set(key, value);
+      }
+    }
+    if (!isGatewayRequest) {
+      stripPlaceholderAuthorization(headers, GATEWAY_PLACEHOLDER_API_KEY);
+    }
+    return executeRequestPipeline(
+      resolvedConfig,
+      {
+        url: resolvedUrl.toString(),
+        method: init?.method ?? requestClone?.method ?? "GET",
+        headers: headersToRecord(headers),
+        body: init?.body ?? requestClone?.body,
+        signal: init?.signal ?? requestClone?.signal
+      },
+      {
+        includeConfigHeaders: isGatewayRequest,
+        includeAuth: isGatewayRequest,
+        includeRequestId: isGatewayRequest,
+        normalizeErrors: isGatewayRequest && normalizeErrors,
+        allowAuthRetry: isGatewayRequest,
+        requestIdPrefix: "provider"
+      }
+    );
+  };
+}
+
+// src/gateway-provider.ts
+var DEFAULT_API_VERSION = "v1";
+function createAIGatewayProvider(options) {
+  const baseURL = resolveGatewayBaseURL(options.baseURL, options.env, "AIGatewayProvider");
+  const customFetch = createGatewayFetch({ ...options, baseURL, normalizeErrors: options.normalizeErrors });
+  const openAI = options.createOpenAI ?? openai.createOpenAI;
+  return openAI({
+    name: options.name,
+    organization: options.organization,
+    project: options.project,
+    baseURL: `${baseURL.replace(/\/$/, "")}/api/${DEFAULT_API_VERSION}`,
+    fetch: customFetch,
+    apiKey: GATEWAY_PLACEHOLDER_API_KEY
+  });
+}
+var GATEWAY_PROVIDERS = {
+  ANTHROPIC: "anthropic",
+  GOOGLE: "google",
+  XAI: "xai",
+  GROQ: "groq",
+  MISTRAL: "mistral",
+  AMAZON_BEDROCK: "amazon-bedrock",
+  AZURE: "azure",
+  COHERE: "cohere",
+  PERPLEXITY: "perplexity",
+  DEEPSEEK: "deepseek",
+  TOGETHERAI: "togetherai",
+  OPENAI_COMPATIBLE: "openai-compatible"
+};
+var GATEWAY_PROVIDER_DEFAULT_PREFIXES = {
+  [GATEWAY_PROVIDERS.ANTHROPIC]: "anthropic",
+  [GATEWAY_PROVIDERS.GOOGLE]: "google",
+  [GATEWAY_PROVIDERS.XAI]: "xai",
+  [GATEWAY_PROVIDERS.GROQ]: "groq",
+  [GATEWAY_PROVIDERS.MISTRAL]: "mistral",
+  [GATEWAY_PROVIDERS.AMAZON_BEDROCK]: "bedrock",
+  [GATEWAY_PROVIDERS.AZURE]: "azure",
+  [GATEWAY_PROVIDERS.COHERE]: "cohere",
+  [GATEWAY_PROVIDERS.PERPLEXITY]: "perplexity",
+  [GATEWAY_PROVIDERS.DEEPSEEK]: "deepseek",
+  [GATEWAY_PROVIDERS.TOGETHERAI]: "togetherai"
+};
+function prefixModelId(prefix, modelId) {
+  return modelId.includes("/") ? modelId : `${prefix}/${modelId}`;
+}
+function createPrefixedGatewayProvider(defaultPrefix, options) {
+  const { modelPrefix, ...providerOptions } = options;
+  const prefix = modelPrefix ?? defaultPrefix;
+  const provider = createAIGatewayProvider(providerOptions);
+  const wrapped = ((modelId) => provider(prefixModelId(prefix, modelId)));
+  return new Proxy(wrapped, {
+    apply(_target, _thisArg, args) {
+      const [modelId, ...rest] = args;
+      return provider(prefixModelId(prefix, modelId), ...rest);
+    },
+    get(_target, prop) {
+      const value = Reflect.get(provider, prop, provider);
+      if (typeof value === "function") {
+        return (...args) => {
+          if (typeof args[0] === "string") {
+            args[0] = prefixModelId(prefix, args[0]);
+          }
+          return value.apply(provider, args);
+        };
+      }
+      return value;
+    },
+    has(_target, prop) {
+      return prop in provider;
+    }
+  });
+}
+function createGatewayProvider(provider, options) {
+  if (provider === GATEWAY_PROVIDERS.OPENAI_COMPATIBLE) {
+    return createPrefixedGatewayProvider(
+      options.modelPrefix,
+      options
+    );
+  }
+  return createPrefixedGatewayProvider(
+    GATEWAY_PROVIDER_DEFAULT_PREFIXES[provider],
+    options
+  );
+}
+
+Object.defineProperty(exports, "AIGatewayError", {
+  enumerable: true,
+  get: function () { return chunkN26BDEG5_cjs.AIGatewayError; }
+});
+Object.defineProperty(exports, "AuthError", {
+  enumerable: true,
+  get: function () { return chunkN26BDEG5_cjs.AuthError; }
+});
+Object.defineProperty(exports, "CreditsError", {
+  enumerable: true,
+  get: function () { return chunkN26BDEG5_cjs.CreditsError; }
+});
+Object.defineProperty(exports, "ErrorCode", {
+  enumerable: true,
+  get: function () { return chunkN26BDEG5_cjs.ErrorCode; }
+});
+Object.defineProperty(exports, "GatewayApiCode", {
+  enumerable: true,
+  get: function () { return chunkN26BDEG5_cjs.GatewayApiCode; }
+});
+Object.defineProperty(exports, "GatewayValidationError", {
+  enumerable: true,
+  get: function () { return chunkN26BDEG5_cjs.GatewayValidationError; }
+});
+Object.defineProperty(exports, "ModelNotAllowedError", {
+  enumerable: true,
+  get: function () { return chunkN26BDEG5_cjs.ModelNotAllowedError; }
+});
+Object.defineProperty(exports, "RateLimitError", {
+  enumerable: true,
+  get: function () { return chunkN26BDEG5_cjs.RateLimitError; }
+});
+Object.defineProperty(exports, "isAIGatewayError", {
+  enumerable: true,
+  get: function () { return chunkN26BDEG5_cjs.isAIGatewayError; }
+});
+Object.defineProperty(exports, "parseErrorResponse", {
+  enumerable: true,
+  get: function () { return chunkN26BDEG5_cjs.parseErrorResponse; }
+});
+exports.GATEWAY_PLACEHOLDER_API_KEY = GATEWAY_PLACEHOLDER_API_KEY;
+exports.GATEWAY_PROVIDERS = GATEWAY_PROVIDERS;
+exports.createAIGatewayProvider = createAIGatewayProvider;
+exports.createGatewayFetch = createGatewayFetch;
+exports.createGatewayProvider = createGatewayProvider;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map