@absolutejs/ai 0.0.21 → 0.0.22

package/dist/ai/index.js

@@ -1,15 +1,236 @@
 // @bun
 var __require = import.meta.require;
 
-// src/ai/providers/instrumentation.ts
-var instrumentAIProvider = (provider, providerName) => ({
-  stream: (params) => {
-    if (!params.onUsage && !params.onSpan) {
-      return provider.stream(params);
-    }
-    return tapStream(provider.stream(params), params, providerName);
+// src/ai/errors/providerError.ts
+var PROVIDER_STATUS_PAGES = {
+  anthropic: "https://status.anthropic.com",
+  gemini: "https://status.cloud.google.com",
+  google: "https://status.cloud.google.com",
+  openai: "https://status.openai.com"
+};
+var RETRYABLE_STATUSES = new Set([
+  408,
+  409,
+  425,
+  429,
+  500,
+  502,
+  503,
+  504,
+  529
+]);
+var CONNECTION_ERROR_PATTERNS = [
+  "econnreset",
+  "econnrefused",
+  "etimedout",
+  "enotfound",
+  "eai_again",
+  "socket hang up",
+  "fetch failed",
+  "network",
+  "terminated",
+  "timed out",
+  "timeout",
+  "and not retryable",
+  "no response body"
+];
+var isAbortError = (err) => err instanceof Error && (err.name === "AbortError" || /\babort(ed)?\b/i.test(err.message));
+var providerStatusPage = (provider) => PROVIDER_STATUS_PAGES[provider] ?? null;
+
+class ProviderError extends Error {
+  provider;
+  status;
+  type;
+  retryable;
+  statusPageUrl;
+  constructor(init) {
+    super(init.message, init.cause === undefined ? undefined : { cause: init.cause });
+    this.name = "ProviderError";
+    this.provider = init.provider;
+    this.status = init.status ?? null;
+    this.type = init.type ?? null;
+    this.retryable = init.retryable;
+    this.statusPageUrl = providerStatusPage(init.provider);
+  }
+  static fromResponse(provider, status, body, type) {
+    return new ProviderError({
+      message: `${capitalize(provider)} API error ${status}: ${body}`,
+      provider,
+      retryable: RETRYABLE_STATUSES.has(status),
+      status,
+      type: type ?? null
+    });
+  }
+  static from(err, provider) {
+    if (err instanceof ProviderError)
+      return err;
+    if (isAbortError(err))
+      throw err;
+    const rawMessage = err instanceof Error ? err.message : String(err ?? "");
+    const lower = rawMessage.toLowerCase();
+    const statusMatch = lower.match(/api error\s+(\d{3})/);
+    const status = statusMatch ? Number(statusMatch[1]) : null;
+    const retryable = status !== null && RETRYABLE_STATUSES.has(status) || status === null && CONNECTION_ERROR_PATTERNS.some((pattern) => lower.includes(pattern));
+    return new ProviderError({
+      cause: err,
+      message: rawMessage || `${capitalize(provider)} request failed`,
+      provider,
+      retryable,
+      status
+    });
   }
+}
+var capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
+
+// src/ai/resilience.ts
+var DEFAULT_CONFIG = {
+  baseDelayMs: 500,
+  failureThreshold: 4,
+  maxDelayMs: 8000,
+  maxRetries: 2,
+  openMs: 30000
+};
+var config = { ...DEFAULT_CONFIG };
+var configureProviderResilience = (partial) => {
+  config = { ...config, ...partial };
+};
+var health = new Map;
+var recordFor = (provider) => {
+  const existing = health.get(provider);
+  if (existing)
+    return existing;
+  const fresh = {
+    consecutiveFailures: 0,
+    lastError: null,
+    lastFailureAt: null,
+    lastSuccessAt: null,
+    nextProbeAt: null,
+    state: "closed"
+  };
+  health.set(provider, fresh);
+  return fresh;
+};
+var noteSuccess = (provider) => {
+  const record = recordFor(provider);
+  record.state = "closed";
+  record.consecutiveFailures = 0;
+  record.nextProbeAt = null;
+  record.lastError = null;
+  record.lastSuccessAt = Date.now();
+};
+var noteFailure = (provider, error) => {
+  const record = recordFor(provider);
+  record.consecutiveFailures += 1;
+  record.lastFailureAt = Date.now();
+  record.lastError = {
+    message: error.message,
+    status: error.status,
+    type: error.type
+  };
+  if (record.consecutiveFailures >= config.failureThreshold) {
+    record.state = "open";
+    record.nextProbeAt = Date.now() + config.openMs;
+  }
+};
+var snapshot = (provider, record) => ({
+  consecutiveFailures: record.consecutiveFailures,
+  healthy: record.state === "closed",
+  lastError: record.lastError,
+  lastFailureAt: record.lastFailureAt,
+  lastSuccessAt: record.lastSuccessAt,
+  nextRetryAt: record.nextProbeAt,
+  provider,
+  state: record.state,
+  statusPageUrl: providerStatusPage(provider)
 });
+function getProviderHealth(provider) {
+  if (provider !== undefined)
+    return snapshot(provider, recordFor(provider));
+  return [...health.entries()].map(([name, record]) => snapshot(name, record));
+}
+var backoffDelay = (attempt) => {
+  const exponential = config.baseDelayMs * 2 ** attempt;
+  const capped = Math.min(exponential, config.maxDelayMs);
+  return Math.round(capped / 2 + Math.random() * capped / 2);
+};
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(signal.reason ?? new Error("aborted"));
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(signal?.reason ?? new Error("aborted"));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var circuitOpen = (provider) => {
+  const record = recordFor(provider);
+  if (record.state !== "open")
+    return null;
+  if (record.nextProbeAt !== null && Date.now() >= record.nextProbeAt) {
+    record.state = "half-open";
+    return null;
+  }
+  const detail = record.lastError?.message ?? "recent failures";
+  return new ProviderError({
+    message: `${provider} is temporarily unavailable (circuit open after ${record.consecutiveFailures} failures): ${detail}`,
+    provider,
+    retryable: true,
+    status: record.lastError?.status ?? null,
+    type: record.lastError?.type ?? null
+  });
+};
+var withResilience = (provider, providerName = "unknown") => {
+  const attempt = async function* (params, attemptNo) {
+    let yielded = false;
+    try {
+      for await (const chunk of provider.stream(params)) {
+        yielded = true;
+        yield chunk;
+      }
+      noteSuccess(providerName);
+    } catch (err) {
+      const providerError = ProviderError.from(err, providerName);
+      const canRetry = !yielded && providerError.retryable && attemptNo < config.maxRetries && !params.signal?.aborted;
+      if (canRetry) {
+        await sleep(backoffDelay(attemptNo), params.signal);
+        yield* attempt(params, attemptNo + 1);
+        return;
+      }
+      noteFailure(providerName, providerError);
+      throw providerError;
+    }
+  };
+  return {
+    stream: (params) => {
+      const tripped = circuitOpen(providerName);
+      if (tripped) {
+        return async function* () {
+          throw tripped;
+        }();
+      }
+      return attempt(params, 0);
+    }
+  };
+};
+
+// src/ai/providers/instrumentation.ts
+var instrumentAIProvider = (provider, providerName) => {
+  const resilient = withResilience(provider, providerName);
+  return {
+    stream: (params) => {
+      if (!params.onUsage && !params.onSpan) {
+        return resilient.stream(params);
+      }
+      return tapStream(resilient.stream(params), params, providerName);
+    }
+  };
+};
 async function* tapStream(source, params, providerName) {
   const startedAt = Date.now();
   let lastUsage;
@@ -501,23 +722,27 @@ var fetchOpenAIStream = async function* (baseUrl, apiKey, body, signal) {
   });
   if (!response.ok) {
     const errorText = await response.text();
-    throw new Error(`OpenAI API error ${response.status}: ${errorText}`);
+    throw ProviderError.fromResponse("openai", response.status, errorText);
   }
   if (!response.body) {
-    throw new Error("OpenAI API returned no response body");
+    throw new ProviderError({
+      message: "OpenAI API returned no response body",
+      provider: "openai",
+      retryable: true
+    });
   }
   yield* parseSSEStream(response.body, signal);
 };
-var openai = (config) => {
-  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
-  if (!config.apiKey && !config.tokenSource) {
+var openai = (config2) => {
+  const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL;
+  if (!config2.apiKey && !config2.tokenSource) {
     throw new Error("openai() requires either apiKey or tokenSource");
   }
   const resolveKey = async () => {
-    if (config.tokenSource) {
-      return await Promise.resolve(config.tokenSource());
+    if (config2.tokenSource) {
+      return await Promise.resolve(config2.tokenSource());
     }
-    return config.apiKey;
+    return config2.apiKey;
   };
   return instrumentAIProvider({
     stream: (params) => {
@@ -531,37 +756,37 @@ var openai = (config) => {
 };
 
 // src/ai/providers/openaiCompatible.ts
-var alibaba = (config) => openaiCompatible({
-  apiKey: config.apiKey,
+var alibaba = (config2) => openaiCompatible({
+  apiKey: config2.apiKey,
   baseUrl: "https://dashscope-intl.aliyuncs.com/compatible-mode"
 });
-var deepseek = (config) => openaiCompatible({
-  apiKey: config.apiKey,
+var deepseek = (config2) => openaiCompatible({
+  apiKey: config2.apiKey,
   baseUrl: "https://api.deepseek.com"
 });
-var google = (config) => openaiCompatible({
-  apiKey: config.apiKey,
+var google = (config2) => openaiCompatible({
+  apiKey: config2.apiKey,
   baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai"
 });
-var meta = (config) => openaiCompatible({
-  apiKey: config.apiKey,
+var meta = (config2) => openaiCompatible({
+  apiKey: config2.apiKey,
   baseUrl: "https://api.llama.com/compat/v1"
 });
-var mistralai = (config) => openaiCompatible({
-  apiKey: config.apiKey,
+var mistralai = (config2) => openaiCompatible({
+  apiKey: config2.apiKey,
   baseUrl: "https://api.mistral.ai"
 });
-var moonshot = (config) => openaiCompatible({
-  apiKey: config.apiKey,
+var moonshot = (config2) => openaiCompatible({
+  apiKey: config2.apiKey,
   baseUrl: "https://api.moonshot.ai"
 });
-var openaiCompatible = (config) => openai({
-  apiKey: config.apiKey,
-  baseUrl: config.baseUrl,
-  tokenSource: config.tokenSource
+var openaiCompatible = (config2) => openai({
+  apiKey: config2.apiKey,
+  baseUrl: config2.baseUrl,
+  tokenSource: config2.tokenSource
 });
-var xai = (config) => openaiCompatible({
-  apiKey: config.apiKey,
+var xai = (config2) => openaiCompatible({
+  apiKey: config2.apiKey,
   baseUrl: "https://api.x.ai"
 });
 
@@ -973,14 +1198,14 @@ var resolveImageModels = (imageModels) => {
   }
   return new Set(imageModels);
 };
-var openaiResponses = (config) => {
-  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL2;
-  const imageModels = resolveImageModels(config.imageModels);
+var openaiResponses = (config2) => {
+  const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL2;
+  const imageModels = resolveImageModels(config2.imageModels);
   return instrumentAIProvider({
     stream: (params) => {
       const isImageModel = imageModels.has(params.model);
       const body = buildRequestBody2(params, isImageModel);
-      return fetchResponsesStream(baseUrl, config.apiKey, body, params.signal);
+      return fetchResponsesStream(baseUrl, config2.apiKey, body, params.signal);
     }
   }, "openai-responses");
 };
@@ -1265,14 +1490,14 @@ var resolveImageModels2 = (raw) => {
   }
   return new Set(raw);
 };
-var gemini = (config) => {
-  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL3;
-  const imageModels = resolveImageModels2(config.imageModels);
+var gemini = (config2) => {
+  const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL3;
+  const imageModels = resolveImageModels2(config2.imageModels);
   return instrumentAIProvider({
     stream: (params) => {
       const isImageModel = imageModels.has(params.model);
       const body = buildRequestBody3(params, isImageModel);
-      return fetchGeminiStream(baseUrl, config.apiKey, params.model, body, params.signal);
+      return fetchGeminiStream(baseUrl, config2.apiKey, params.model, body, params.signal);
     }
   }, "gemini");
 };
@@ -1545,7 +1770,14 @@ var handleMessageStart = (parsed, state) => {
 var handleError = (parsed) => {
   const error = getRecord(parsed, "error");
   const errorMessage = error ? getString(error, "message") : "";
-  throw new Error(errorMessage || "Anthropic API error");
+  const errorType = error ? getString(error, "type") : "";
+  const retryable = errorType === "overloaded_error" || errorType === "rate_limit_error" || errorType === "api_error";
+  throw new ProviderError({
+    message: errorMessage || "Anthropic API error",
+    provider: "anthropic",
+    retryable,
+    type: errorType || null
+  });
 };
 var processEvent = (eventType, parsed, state) => {
   switch (eventType) {
@@ -1654,7 +1886,7 @@ async function* parseSSEStream4(body, signal) {
     reader.releaseLock();
   }
 }
-var fetchAndStream = async function* (baseUrl, config, params) {
+var fetchAndStream = async function* (baseUrl, config2, params) {
   const body = buildRequestBody4(params);
   const target = `${baseUrl}/v1/messages`;
   const response = await fetch(target, {
@@ -1663,24 +1895,28 @@ var fetchAndStream = async function* (baseUrl, config, params) {
     headers: {
       "anthropic-version": API_VERSION,
       "Content-Type": "application/json",
-      "x-api-key": config.apiKey
+      "x-api-key": config2.apiKey
     },
     method: "POST",
     signal: params.signal
   });
   if (!response.ok) {
     const errorText = await response.text();
-    throw new Error(`Anthropic API error ${response.status}: ${errorText}`);
+    throw ProviderError.fromResponse("anthropic", response.status, errorText);
   }
   if (!response.body) {
-    throw new Error("Anthropic API returned no response body");
+    throw new ProviderError({
+      message: "Anthropic API returned no response body",
+      provider: "anthropic",
+      retryable: true
+    });
   }
   yield* parseSSEStream4(response.body, params.signal);
 };
-var anthropic = (config) => {
-  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL4;
+var anthropic = (config2) => {
+  const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL4;
   return instrumentAIProvider({
-    stream: (params) => fetchAndStream(baseUrl, config, params)
+    stream: (params) => fetchAndStream(baseUrl, config2, params)
   }, "anthropic");
 };
 
@@ -1915,8 +2151,8 @@ var fetchAndStream2 = async function* (baseUrl, params) {
   }
   yield* parseNDJSONStream(response.body, params.signal);
 };
-var ollama = (config = {}) => {
-  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL5;
+var ollama = (config2 = {}) => {
+  const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL5;
   return instrumentAIProvider({
     stream: (params) => fetchAndStream2(baseUrl, params)
   }, "ollama");
@@ -2747,24 +2983,24 @@ var buildUserMessage = (content, attachments) => {
   }
   return { content, role: "user" };
 };
-var resolveModel = (config, parsed) => {
+var resolveModel = (config2, parsed) => {
   if (parsed.model) {
     return parsed.model;
   }
-  if (typeof config.model === "string") {
-    return config.model;
+  if (typeof config2.model === "string") {
+    return config2.model;
   }
-  if (typeof config.model === "function") {
-    return config.model(parsed.providerName);
+  if (typeof config2.model === "function") {
+    return config2.model(parsed.providerName);
   }
   return parsed.providerName;
 };
-var resolveTools = (config, providerName, model) => typeof config.tools === "function" ? config.tools(providerName, model) : config.tools;
-var resolveReasoning = (config, providerName, model) => typeof config.reasoning === "function" ? config.reasoning(providerName, model) : config.reasoning;
-var aiChat = (config) => {
-  const path = config.path ?? DEFAULT_PATH;
-  const store = config.store ?? createMemoryStore();
-  const parseProvider = config.parseProvider ?? defaultParseProvider;
+var resolveTools = (config2, providerName, model) => typeof config2.tools === "function" ? config2.tools(providerName, model) : config2.tools;
+var resolveReasoning = (config2, providerName, model) => typeof config2.reasoning === "function" ? config2.reasoning(providerName, model) : config2.reasoning;
+var aiChat = (config2) => {
+  const path = config2.path ?? DEFAULT_PATH;
+  const store = config2.store ?? createMemoryStore();
+  const parseProvider = config2.parseProvider ?? defaultParseProvider;
   const abortControllers = new Map;
   const handleCancel = (conversationId) => {
     const controller = abortControllers.get(conversationId);
@@ -2802,17 +3038,17 @@ var aiChat = (config) => {
       timestamp: Date.now()
     });
     await store.set(conversationId, conversation);
-    const model = resolveModel(config, parsed);
+    const model = resolveModel(config2, parsed);
     const userMessage = buildUserMessage(content, attachments);
     await streamAI(ws, conversationId, messageId, {
-      maxTurns: config.maxTurns,
+      maxTurns: config2.maxTurns,
       messages: [...history, userMessage],
       model,
-      provider: config.provider(providerName),
+      provider: config2.provider(providerName),
       signal: controller.signal,
-      systemPrompt: config.systemPrompt,
-      reasoning: resolveReasoning(config, providerName, model),
-      tools: resolveTools(config, providerName, model),
+      systemPrompt: config2.systemPrompt,
+      reasoning: resolveReasoning(config2, providerName, model),
+      tools: resolveTools(config2, providerName, model),
       onComplete: async (fullResponse, usage) => {
         const conv = await store.get(conversationId);
         if (conv) {
@@ -2826,15 +3062,15 @@ var aiChat = (config) => {
           await store.set(conversationId, conv);
         }
         abortControllers.delete(conversationId);
-        config.onComplete?.(conversationId, fullResponse, usage);
+        config2.onComplete?.(conversationId, fullResponse, usage);
       }
     });
   };
   const htmxRoutes = () => {
-    if (!config.htmx) {
+    if (!config2.htmx) {
       return new Elysia;
     }
-    const renderers = resolveRenderers(typeof config.htmx === "object" ? config.htmx.render : undefined);
+    const renderers = resolveRenderers(typeof config2.htmx === "object" ? config2.htmx.render : undefined);
     return new Elysia().post(`${path}/message`, async ({ body }) => {
       const requestBody = body && typeof body === "object" ? body : {};
       const rawContent = "content" in requestBody ? String(requestBody.content) : undefined;
@@ -2872,21 +3108,21 @@ var aiChat = (config) => {
       }
       const parsed = parseProvider(conversation.messages.at(EXCLUDE_LAST_OFFSET)?.content ?? "");
       const { providerName } = parsed;
-      const model = resolveModel(config, parsed);
+      const model = resolveModel(config2, parsed);
       const controller = new AbortController;
       abortControllers.set(conversationId, controller);
       const history = getHistory(conversation);
       const lastMsg = conversation.messages.at(EXCLUDE_LAST_OFFSET);
       const userMessage = buildUserMessage(lastMsg?.content ?? "", lastMsg?.attachments);
       const sseStream = streamAIToSSE(conversationId, messageId, {
-        maxTurns: config.maxTurns,
+        maxTurns: config2.maxTurns,
         messages: [...history.slice(0, EXCLUDE_LAST_OFFSET), userMessage],
         model,
-        provider: config.provider(providerName),
+        provider: config2.provider(providerName),
         signal: controller.signal,
-        systemPrompt: config.systemPrompt,
-        reasoning: resolveReasoning(config, providerName, model),
-        tools: resolveTools(config, providerName, model)
+        systemPrompt: config2.systemPrompt,
+        reasoning: resolveReasoning(config2, providerName, model),
+        tools: resolveTools(config2, providerName, model)
       }, renderers);
       for await (const event of sseStream) {
         yield event;
@@ -3742,12 +3978,12 @@ var createAIStream = (path, conversationId) => {
   let currentMessages = [];
   let activeConversationId = conversationId ?? null;
   const syncState = () => {
-    const snapshot = store.getSnapshot();
-    const convId = activeConversationId ?? snapshot.activeConversationId;
-    const conversation = convId ? snapshot.conversations.get(convId) : undefined;
-    activeConversationId = convId ?? snapshot.activeConversationId;
-    currentError = snapshot.error;
-    currentIsStreaming = snapshot.isStreaming;
+    const snapshot2 = store.getSnapshot();
+    const convId = activeConversationId ?? snapshot2.activeConversationId;
+    const conversation = convId ? snapshot2.conversations.get(convId) : undefined;
+    activeConversationId = convId ?? snapshot2.activeConversationId;
+    currentError = snapshot2.error;
+    currentIsStreaming = snapshot2.isStreaming;
     currentMessages = conversation?.messages ?? [];
     listeners.forEach((listener) => listener());
   };
@@ -3828,35 +4064,35 @@ var readOAuth2ErrorDetail = async (response) => {
   const text = await response.clone().text().catch(() => "");
   return text.trim();
 };
-var createOAuth2ClientCredentialsTokenSource = (config) => {
-  const fetchImpl = config.fetch ?? fetch;
-  const now = config.now ?? (() => Date.now());
-  const skewMs = config.expirySkewMs ?? 60000;
-  const fallbackTtl = config.fallbackTtlSeconds ?? 3600;
-  const scope = Array.isArray(config.scope) ? config.scope.join(" ") : config.scope;
+var createOAuth2ClientCredentialsTokenSource = (config2) => {
+  const fetchImpl = config2.fetch ?? fetch;
+  const now = config2.now ?? (() => Date.now());
+  const skewMs = config2.expirySkewMs ?? 60000;
+  const fallbackTtl = config2.fallbackTtlSeconds ?? 3600;
+  const scope = Array.isArray(config2.scope) ? config2.scope.join(" ") : config2.scope;
   let cached = null;
   let inflight = null;
   const requestToken = async () => {
     const body = new URLSearchParams({ grant_type: "client_credentials" });
     if (scope)
       body.set("scope", scope);
-    if (config.audience)
-      body.set("audience", config.audience);
-    for (const [key, value] of Object.entries(config.extraParams ?? {})) {
+    if (config2.audience)
+      body.set("audience", config2.audience);
+    for (const [key, value] of Object.entries(config2.extraParams ?? {})) {
       body.set(key, value);
     }
     const headers = {
       Accept: "application/json",
       "Content-Type": "application/x-www-form-urlencoded"
     };
-    if (config.authStyle === "basic") {
-      const encoded = btoa(`${config.clientId}:${config.clientSecret}`);
+    if (config2.authStyle === "basic") {
+      const encoded = btoa(`${config2.clientId}:${config2.clientSecret}`);
       headers.Authorization = `Basic ${encoded}`;
     } else {
-      body.set("client_id", config.clientId);
-      body.set("client_secret", config.clientSecret);
+      body.set("client_id", config2.clientId);
+      body.set("client_secret", config2.clientSecret);
     }
-    const response = await fetchImpl(config.tokenUrl, {
+    const response = await fetchImpl(config2.tokenUrl, {
       body,
       headers,
       method: "POST"
@@ -3890,11 +4126,13 @@ var createOAuth2ClientCredentialsTokenSource = (config) => {
 };
 export {
   xai,
+  withResilience,
   streamAIToSSE,
   streamAI,
   serverMessageToAction,
   serializeAIMessage,
   resolveRenderers,
+  providerStatusPage,
   parseAIMessage,
   openaiResponses,
   openaiCompatible,
@@ -3904,6 +4142,7 @@ export {
   mistralai,
   meta,
   google,
+  getProviderHealth,
   generateObjectAI,
   generateId,
   generateAIWithTools,
@@ -3916,10 +4155,13 @@ export {
   createConversationManager,
   createAIStream,
   createAIConnection,
+  configureProviderResilience,
   anthropic,
   alibaba,
-  aiChat
+  aiChat,
+  ProviderError,
+  PROVIDER_STATUS_PAGES
 };
 
-//# debugId=8280CFC77A5D2DF464756E2164756E21
+//# debugId=4F9632D62D06633E64756E2164756E21
 //# sourceMappingURL=index.js.map