sermon-js 0.1.0 → 0.3.0

package/dist/presets/index.js

@@ -17,9 +17,9 @@ function withKeys(machines) {
   const seen = /* @__PURE__ */ new Map();
   return [...machines].sort((a, b) => (a.region ?? "").localeCompare(b.region ?? "") || a.id.localeCompare(b.id)).map((machine) => {
     const region = machine.region ?? "unknown";
-    const count = (seen.get(region) ?? 0) + 1;
-    seen.set(region, count);
-    return { machine, region, key: count === 1 ? region : `${region}#${count}` };
+    const count2 = (seen.get(region) ?? 0) + 1;
+    seen.set(region, count2);
+    return { machine, region, key: count2 === 1 ? region : `${region}#${count2}` };
   });
 }
 function median(values) {
@@ -221,8 +221,8 @@ var instance = definePreset()({
   }),
   check: async ({ options, secrets, http, now }) => {
     const account = parseServiceAccount(secrets.serviceAccount);
-    const project = options.project ?? account?.project_id;
-    if (!account || !project) {
+    const project2 = options.project ?? account?.project_id;
+    if (!account || !project2) {
       return { status: "down", probed: false, error: "The service account secret is not a service-account JSON key" };
     }
     let token;
@@ -237,7 +237,7 @@ var instance = definePreset()({
       return { status: "down", probed: false, error: error instanceof Error ? error.message : String(error) };
     }
     const info = await http(
-      `https://compute.googleapis.com/compute/v1/projects/${project}/zones/${options.zone}/instances/${options.instance}`,
+      `https://compute.googleapis.com/compute/v1/projects/${project2}/zones/${options.zone}/instances/${options.instance}`,
       { headers: { Authorization: `Bearer ${token}` } }
     );
     const state = info.json?.status;
@@ -260,6 +260,68 @@ var instance = definePreset()({
   }
 });
 var gcp = { instance };
+
+// src/presets/providers/shared.ts
+var bearer = (token) => ({ Authorization: `Bearer ${token}` });
+var round = (value, digits = 1) => Math.round(value * 10 ** digits) / 10 ** digits;
+function base64(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+async function call(http, url, init, refine) {
+  const response = await http(url, init);
+  if (!response.ok || !refine) return response.outcome;
+  return { ...response.outcome, ...normalizeReturn(refine(response)) };
+}
+function quota({
+  label,
+  used,
+  limit,
+  unit,
+  resetsAt,
+  warnAbovePct,
+  warning
+}) {
+  const pct = limit > 0 ? used / limit * 100 : 0;
+  const over = pct >= warnAbovePct;
+  return {
+    status: over ? "degraded" : "up",
+    error: over ? warning : void 0,
+    usage: [{ label, used, limit, unit, resetsAt }]
+  };
+}
+function summarize(instances, noun) {
+  const down = instances.filter((instance2) => instance2.status === "down");
+  const degraded = instances.filter((instance2) => instance2.status === "degraded");
+  const awake = instances.filter((instance2) => instance2.status === "up" || instance2.status === "degraded");
+  const keysOf = (items) => items.map((instance2) => instance2.key).join(", ");
+  const latencies = instances.map((instance2) => instance2.latencyMs).filter((l) => l !== void 0);
+  const latencyMs = latencies.length ? Math.max(...latencies) : void 0;
+  if (instances.length > 0 && down.length === instances.length) {
+    return { status: "down", latencyMs, error: `All ${instances.length} ${noun}(s) failing` };
+  }
+  if (down.length > 0) {
+    return { status: "degraded", latencyMs, error: `${down.length}/${instances.length} ${noun}(s) failing: ${keysOf(down)}` };
+  }
+  if (degraded.length > 0) return { status: "degraded", latencyMs, error: `Degraded: ${keysOf(degraded)}` };
+  return { status: awake.length || instances.length === 0 ? "up" : "sleeping", latencyMs };
+}
+function keyAccepted(res) {
+  if (res.status === 400 || res.status === 422) return { status: "up", latencyMs: res.latencyMs, httpStatus: res.status };
+  if (res.status === 402) {
+    return { status: "degraded", latencyMs: res.latencyMs, httpStatus: 402, error: "Out of credits, or payment required" };
+  }
+  return res.outcome;
+}
+var emptyPost = (headers) => ({
+  method: "POST",
+  headers: { "content-type": "application/json", ...headers },
+  body: "{}"
+});
+
+// src/presets/aws.ts
 async function signedCall({
   http,
   secrets,
@@ -319,7 +381,170 @@ var s3Bucket = definePreset()({
     return response.outcome;
   }
 });
-var aws = { credentials, s3Bucket };
+function pingBody(model) {
+  if (/(^|\.)cohere\.embed/.test(model)) return { texts: ["ping"], input_type: "search_query" };
+  return { anthropic_version: "bedrock-2023-05-31", max_tokens: 1, messages: [{ role: "user", content: "ping" }] };
+}
+var bedrockPreset = definePreset()({
+  kind: "aws.bedrock",
+  requiredFields: ["region"],
+  requiredSecrets: "all",
+  defaults: { slowMs: 5e3, timeoutMs: 2e4 },
+  derive: () => ({
+    name: "Amazon Bedrock",
+    identity: "aws.bedrock",
+    description: "Invokes each monitored model with one token"
+  }),
+  check: async ({ options, secrets, http }) => {
+    const signer = secrets.accessKeyId && secrets.secretAccessKey ? new AwsClient({
+      accessKeyId: secrets.accessKeyId,
+      secretAccessKey: secrets.secretAccessKey,
+      service: "bedrock",
+      region: options.region
+    }) : void 0;
+    const invoke = async (model) => {
+      const url = `https://bedrock-runtime.${options.region}.amazonaws.com/model/${encodeURIComponent(model)}/invoke`;
+      const init = {
+        method: "POST",
+        headers: { "content-type": "application/json", accept: "application/json" },
+        body: JSON.stringify(pingBody(model))
+      };
+      if (!signer) return http(url, { ...init, headers: { ...init.headers, ...bearer(secrets.bearerToken ?? "") } });
+      const signed = await signer.sign(url, init);
+      return http(signed.url, { ...init, headers: Object.fromEntries(signed.headers.entries()) });
+    };
+    const instances = await Promise.all(
+      [...new Set(options.models)].map(async (model) => {
+        const res = await invoke(model);
+        return {
+          key: model,
+          status: res.outcome.status,
+          latencyMs: res.status === void 0 ? void 0 : res.latencyMs,
+          httpStatus: res.status,
+          error: res.outcome.error
+        };
+      })
+    );
+    return { ...summarize(instances, "model"), instances, instanceLabels: { key: "Model" } };
+  }
+});
+function bedrock(options) {
+  const { bearerToken, accessKeyId, secretAccessKey } = options.secrets;
+  return bedrockPreset({ ...options, secrets: bearerToken ? { bearerToken } : { accessKeyId, secretAccessKey } });
+}
+var aws = { credentials, s3Bucket, bedrock };
+
+// src/presets/neon.ts
+var API = "https://console.neon.tech/api/v2";
+var GB = 1024 ** 3;
+function withKeys2(endpoints, branches) {
+  const seen = /* @__PURE__ */ new Map();
+  return endpoints.map((endpoint) => {
+    const name = branches.get(endpoint.branch_id)?.name ?? endpoint.branch_id;
+    const count2 = (seen.get(name) ?? 0) + 1;
+    seen.set(name, count2);
+    return { endpoint, key: count2 === 1 ? name : `${name}#${count2}` };
+  });
+}
+var project = definePreset()({
+  kind: "neon.project",
+  requiredFields: ["projectId"],
+  requiredSecrets: ["apiKey"],
+  defaults: { slowMs: 1e3 },
+  derive: (options) => ({
+    name: "Neon",
+    identity: `neon.project:${options.projectId ?? ""}`,
+    description: "Compute states from the Neon API, then `select 1` on an active compute only"
+  }),
+  check: async ({ options, secrets, http, measure }) => {
+    const base = `${API}/projects/${encodeURIComponent(options.projectId)}`;
+    const headers = { ...bearer(secrets.apiKey), accept: "application/json" };
+    const [list, info, branchList] = await Promise.all([
+      http(`${base}/endpoints`, { headers }),
+      http(base, { headers }),
+      http(`${base}/branches`, { headers })
+    ]);
+    if (list.status === 404) {
+      return { status: "down", probed: false, httpStatus: 404, error: `Project "${options.projectId}" not found on Neon` };
+    }
+    const endpoints = list.json?.endpoints;
+    if (!list.ok || !Array.isArray(endpoints)) {
+      return {
+        status: "degraded",
+        probed: false,
+        httpStatus: list.status,
+        error: list.status ? `Neon API HTTP ${list.status}` : `Neon API unreachable: ${list.outcome.error ?? "no response"}`
+      };
+    }
+    if (endpoints.length === 0) return { status: "down", probed: false, error: "No compute: nothing can connect" };
+    const branches = branchList.json?.branches ?? [];
+    const details = info.json?.project;
+    const byId = new Map(branches.map((branch) => [branch.id, branch]));
+    const defaultBranch = branches.find((branch) => branch.default)?.id;
+    const keyed = withKeys2(endpoints, byId);
+    const target = keyed.find(({ endpoint }) => endpoint.id === options.endpoint) ?? (options.endpoint ? void 0 : keyed.find(({ endpoint }) => endpoint.type === "read_write" && endpoint.branch_id === defaultBranch) ?? keyed.find(({ endpoint }) => endpoint.type === "read_write"));
+    const ping = options.query && target?.endpoint.current_state === "active" && !target.endpoint.disabled ? await measure(async () => void await options.query("select 1")) : void 0;
+    const instances = keyed.map(({ endpoint, key }) => {
+      const row = { key, region: endpoint.region_id, id: endpoint.id };
+      if (endpoint.disabled) return { ...row, state: "disabled", status: "sleeping" };
+      if (endpoint.current_state === "idle") return { ...row, state: "idle", status: "sleeping" };
+      if (endpoint.current_state !== "active") return { ...row, state: endpoint.current_state, status: "degraded" };
+      if (ping && endpoint.id === target?.endpoint.id) {
+        return { ...row, state: "active", status: ping.status, latencyMs: ping.latencyMs, error: ping.error };
+      }
+      return { ...row, state: "active", status: "up" };
+    });
+    const usage = [];
+    const warnings = [];
+    const bar = (entry, warnAbovePct = 90) => {
+      usage.push(entry);
+      if (entry.limit > 0 && entry.used / entry.limit * 100 >= warnAbovePct) warnings.push(`${entry.label} close to the plan limit`);
+    };
+    const compute = options.track?.compute;
+    if (compute && typeof details?.compute_time_seconds === "number") {
+      bar(
+        {
+          label: "Compute this period",
+          used: round(details.compute_time_seconds / 3600),
+          limit: compute.maxHours,
+          unit: "CU-hours",
+          resetsAt: details.consumption_period_end ? Date.parse(details.consumption_period_end) || void 0 : void 0
+        },
+        compute.warnAbovePct
+      );
+    }
+    const storage = options.track?.storage;
+    if (storage && branches.length > 0) {
+      const bytes = branches.reduce((sum, branch) => sum + (branch.logical_size ?? 0), 0);
+      bar({ label: "Storage", used: round(bytes / GB, 2), limit: storage.maxGb, unit: "GB" }, storage.warnAbovePct);
+    }
+    const main = instances.find((instance2) => instance2.id === target?.endpoint.id) ?? instances[0];
+    const active = instances.filter((instance2) => instance2.state === "active").length;
+    let status = main.status;
+    let error = main.error;
+    if (status === "degraded" && !error) error = `Compute is ${main.state}`;
+    if ((status === "up" || status === "sleeping") && warnings.length) {
+      status = "degraded";
+      error = warnings.join("; ");
+    }
+    return {
+      status,
+      probed: !!ping,
+      latencyMs: ping?.latencyMs ?? list.latencyMs,
+      error,
+      metrics: {
+        ...details?.pg_version ? { postgres: details.pg_version } : {},
+        ...details?.region_id ? { region: details.region_id } : {},
+        ...branches.length ? { branches: branches.length } : {},
+        computes: `${active}/${instances.length} active`
+      },
+      usage: usage.length ? usage : void 0,
+      instances,
+      instanceLabels: { key: "Compute", detail: "Endpoint" }
+    };
+  }
+});
+var neon = { project };
 
 // src/presets/databases.ts
 var mongoPing = definePreset()({
@@ -346,38 +571,16 @@ var redisPing = definePreset()({
   })
 });
 var redis = { ping: redisPing };
-
-// src/presets/providers/shared.ts
-var bearer = (token) => ({ Authorization: `Bearer ${token}` });
-var round = (value, digits = 1) => Math.round(value * 10 ** digits) / 10 ** digits;
-function base64(text) {
-  const bytes = new TextEncoder().encode(text);
-  let binary = "";
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary);
-}
-async function call(http, url, init, refine) {
-  const response = await http(url, init);
-  if (!response.ok || !refine) return response.outcome;
-  return { ...response.outcome, ...normalizeReturn(refine(response)) };
-}
-function quota({
-  label,
-  used,
-  limit,
-  unit,
-  resetsAt,
-  warnAbovePct,
-  warning
-}) {
-  const pct = limit > 0 ? used / limit * 100 : 0;
-  const over = pct >= warnAbovePct;
-  return {
-    status: over ? "degraded" : "up",
-    error: over ? warning : void 0,
-    usage: [{ label, used, limit, unit, resetsAt }]
-  };
-}
+var postgresPing = definePreset()({
+  kind: "postgres.ping",
+  requiredFields: ["query"],
+  defaults: { slowMs: 1e3 },
+  derive: () => ({ name: "PostgreSQL", description: "Runs `select 1`" }),
+  check: ({ options, measure }) => measure(async () => {
+    await options.query("select 1");
+  })
+});
+var postgres = { ping: postgresPing };
 
 // src/presets/providers/ai.ts
 var deepgram = definePreset()({
@@ -442,13 +645,33 @@ var openai = definePreset()({
     }
   )
 });
+var API2 = "https://api.anthropic.com/v1/models";
 var anthropic = definePreset()({
   kind: "anthropic",
   requiredSecrets: ["apiKey"],
-  derive: () => ({ name: "Anthropic", identity: "anthropic", description: "Lists models" }),
-  check: ({ secrets, http }) => call(http, "https://api.anthropic.com/v1/models?limit=1", {
-    headers: { "x-api-key": secrets.apiKey, "anthropic-version": "2023-06-01" }
-  })
+  derive: (options) => ({
+    name: "Anthropic",
+    identity: "anthropic",
+    description: options.track?.models?.length ? "Reads each monitored model" : "Lists models"
+  }),
+  check: async ({ options, secrets, http }) => {
+    const headers = { "x-api-key": secrets.apiKey, "anthropic-version": "2023-06-01" };
+    const models = [...new Set(options.track?.models ?? [])];
+    if (models.length === 0) return (await http(`${API2}?limit=1`, { headers })).outcome;
+    const responses = await Promise.all(
+      models.map(async (model) => ({ model, res: await http(`${API2}/${encodeURIComponent(model)}`, { headers }) }))
+    );
+    const rejected = responses.find(({ res }) => res.status === 401 || res.status === 403);
+    if (rejected) return rejected.res.outcome;
+    const instances = responses.map(({ model, res }) => {
+      const base = { key: model, latencyMs: res.status === void 0 ? void 0 : res.latencyMs, httpStatus: res.status };
+      if (res.ok) return { ...base, status: "up" };
+      if (res.status === 404) return { ...base, status: "down", error: "Model not found: retired, or not available to this key" };
+      if (res.status === 529) return { ...base, status: "degraded", error: "Overloaded" };
+      return { ...base, status: res.outcome.status, error: res.outcome.error };
+    });
+    return { ...summarize(instances, "model"), instances, instanceLabels: { key: "Model" } };
+  }
 });
 var gemini = definePreset()({
   kind: "gemini",
@@ -464,6 +687,38 @@ var cambai = definePreset()({
   derive: () => ({ name: "CAMB.AI", identity: "cambai", description: "Lists source languages" }),
   check: ({ secrets, http }) => call(http, "https://client.camb.ai/apis/source-languages", { headers: { "x-api-key": secrets.apiKey } })
 });
+var elevenlabs = definePreset()({
+  kind: "elevenlabs",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "ElevenLabs", identity: "elevenlabs", description: "Reads the subscription" }),
+  check: async ({ options, secrets, http }) => {
+    const res = await http("https://api.elevenlabs.io/v1/user/subscription", {
+      headers: { "xi-api-key": secrets.apiKey }
+    });
+    const body = res.json ?? {};
+    if (res.status === 401 && body.detail?.status === "missing_permissions") {
+      return { status: "up", latencyMs: res.latencyMs, httpStatus: 401, metrics: { key: "restricted" } };
+    }
+    if (!res.ok) return res.outcome;
+    const metrics = body.tier ? { tier: body.tier } : void 0;
+    const { character_count: used, character_limit: limit } = body;
+    if (typeof used !== "number" || !limit) return { ...res.outcome, metrics };
+    return {
+      ...res.outcome,
+      ...quota({
+        label: "Credits",
+        used,
+        limit,
+        unit: "credits",
+        // ElevenLabs gives the reset as epoch seconds
+        resetsAt: body.next_character_count_reset_unix ? body.next_character_count_reset_unix * 1e3 : void 0,
+        warnAbovePct: 100 - (options.track?.quota?.warnBelowPct ?? 10),
+        warning: "Credits almost exhausted"
+      }),
+      metrics
+    };
+  }
+});
 
 // src/presets/providers/translation.ts
 var deepl = definePreset()({
@@ -695,6 +950,64 @@ var statuspage = definePreset()({
     return { status, error: status === "up" ? void 0 : description };
   })
 });
+var resend = definePreset()({
+  kind: "resend",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Resend", identity: "resend", description: "Lists domains" }),
+  check: async ({ secrets, http }) => {
+    const res = await http("https://api.resend.com/domains", { headers: bearer(secrets.apiKey) });
+    const body = res.json ?? {};
+    if (res.status === 401 && body.name === "restricted_api_key") {
+      return { status: "up", latencyMs: res.latencyMs, httpStatus: 401, metrics: { key: "sending only" } };
+    }
+    if (!res.ok || !Array.isArray(body.data)) return res.outcome;
+    const verified = body.data.filter((domain) => domain.status === "verified").length;
+    const unverified = body.data.length > 0 && verified === 0;
+    return {
+      ...res.outcome,
+      status: unverified ? "degraded" : "up",
+      error: unverified ? "No verified domain" : void 0,
+      metrics: { domains: body.data.length, verified }
+    };
+  }
+});
+var meilisearch = definePreset()({
+  kind: "meilisearch",
+  requiredFields: ["host"],
+  requiredSecrets: ["apiKey"],
+  derive: (options) => ({
+    name: "Meilisearch",
+    identity: options.index ? `meilisearch:${options.index}` : "meilisearch",
+    description: options.index ? `Reads the health and the ${options.index} index` : "Reads the health and lists indexes"
+  }),
+  check: async ({ options, secrets, http, combine }) => {
+    const host = options.host.replace(/\/+$/, "");
+    const headers = bearer(secrets.apiKey);
+    const index = options.index ? `/indexes/${encodeURIComponent(options.index)}` : void 0;
+    const health = call(
+      http,
+      `${host}/health`,
+      void 0,
+      (res2) => res2.json?.status === "available" ? void 0 : { status: "down", error: "Not available" }
+    );
+    const access = http(`${host}${index ?? "/indexes?limit=1"}`, { headers }).then((res2) => {
+      if (res2.status !== 404 || !options.index) return res2.outcome;
+      return {
+        status: "degraded",
+        latencyMs: res2.latencyMs,
+        httpStatus: 404,
+        error: `Index ${options.index} not found`
+      };
+    });
+    const stats = http(`${host}${index ?? ""}/stats`, { headers });
+    const outcome = combine(await Promise.all([health, access]));
+    const res = await stats;
+    if (!res.ok) return outcome;
+    const body = res.json ?? {};
+    const documents = body.numberOfDocuments ?? Object.values(body.indexes ?? {}).reduce((sum, entry) => sum + (entry.numberOfDocuments ?? 0), 0);
+    return { ...outcome, metrics: { ...outcome.metrics, documents, ...body.isIndexing ? { indexing: "yes" } : {} } };
+  }
+});
 
 // src/presets/providers/pusher.ts
 var MAX_CHANNELS = 500;
@@ -778,12 +1091,12 @@ var pusher = definePreset()({
     let countingDisabled = false;
     const counts = await mapLimit(queried, CONCURRENCY, async (name) => {
       const res = await get(`/channels/${encodeURIComponent(name)}`, { info: "subscription_count" });
-      const count = res.json?.subscription_count;
+      const count2 = res.json?.subscription_count;
       if (!res.ok) failed += 1;
-      else if (typeof count !== "number") countingDisabled = true;
-      return typeof count === "number" ? count : 0;
+      else if (typeof count2 !== "number") countingDisabled = true;
+      return typeof count2 === "number" ? count2 : 0;
     });
-    const connections = counts.reduce((sum, count) => sum + count, 0);
+    const connections = counts.reduce((sum, count2) => sum + count2, 0);
     const signedInUsers = queried.reduce(
       (sum, name, index) => name.startsWith("#server-to-user-") ? sum + (counts[index] ?? 0) : sum,
       0
@@ -826,6 +1139,187 @@ var pusher = definePreset()({
   }
 });
 
-export { anthropic, attendee, aws, axiom, azureTranslator, cambai, clearGoogleTokens, cloudflareStream, crashReason, deepgram, deepl, fly, gcp, gemini, github, gladia, googleServiceAccountToken, googleTranslate, mailersend, mongodb, mux, openai, parseServiceAccount, pusher, redis, revolut, signGoogleAssertion, signPusherRequest, speechmatics, statuspage, upstashRedis };
+// src/presets/providers/vercel.ts
+var aiGateway = definePreset()({
+  kind: "vercel.aiGateway",
+  requiredSecrets: ["apiKey"],
+  derive: (options) => ({
+    name: "Vercel AI Gateway",
+    identity: "vercel.aiGateway",
+    description: options.track?.credits === false ? "Lists models" : "Reads the credit balance"
+  }),
+  check: ({ options, secrets, http }) => {
+    const headers = bearer(secrets.apiKey);
+    if (options.track?.credits === false) return call(http, "https://ai-gateway.vercel.sh/v1/models", { headers });
+    const warnBelow = options.track?.credits?.warnBelow ?? 5;
+    return call(http, "https://ai-gateway.vercel.sh/v1/credits", { headers }, (res) => {
+      const body = res.json ?? {};
+      const balance = Number(body.balance);
+      if (body.balance === void 0 || !Number.isFinite(balance)) return void 0;
+      const used = Number(body.total_used);
+      const low = balance < warnBelow;
+      return {
+        status: low ? "degraded" : "up",
+        error: low ? "Low credit balance" : void 0,
+        metrics: {
+          balance: `${round(balance, 2)} USD`,
+          ...body.total_used !== void 0 && Number.isFinite(used) ? { used: `${round(used, 2)} USD` } : {}
+        }
+      };
+    });
+  }
+});
+var blob = definePreset()({
+  kind: "vercel.blob",
+  requiredSecrets: ["token"],
+  derive: () => ({ name: "Vercel Blob", identity: "vercel.blob", description: "Lists one blob of the store" }),
+  check: ({ secrets, http }) => call(http, "https://vercel.com/api/blob?limit=1", {
+    headers: { ...bearer(secrets.token), "x-api-version": "12" }
+  })
+});
+var vercel = { aiGateway, blob };
+
+// src/presets/providers/stripe.ts
+var API3 = "https://api.stripe.com/v1";
+var DAY_S = 24 * 60 * 60;
+var ZERO_DECIMAL = /* @__PURE__ */ new Set(["bif", "clp", "djf", "gnf", "jpy", "kmf", "krw", "mga", "pyg", "rwf", "ugx", "vnd", "vuv", "xaf", "xof", "xpf"]);
+function money(amounts) {
+  return (amounts ?? []).slice(0, 3).map(({ amount, currency }) => {
+    const value = ZERO_DECIMAL.has(currency) ? String(amount) : (amount / 100).toFixed(2);
+    return `${value} ${currency.toUpperCase()}`;
+  }).join(", ");
+}
+function endpointKey(url) {
+  try {
+    const { host, pathname } = new URL(url);
+    return `${host}${pathname}`;
+  } catch {
+    return "endpoint";
+  }
+}
+var count = (list) => `${list.data?.length ?? 0}${list.has_more ? "+" : ""}`;
+var stripe = definePreset()({
+  kind: "stripe",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Stripe", identity: "stripe", description: "Reads the balance, account and webhook endpoints" }),
+  check: async ({ options, secrets, http, now }) => {
+    const { account = true, webhooks = true, disputes = true } = options.track ?? {};
+    const get = (path) => http(`${API3}${path}`, { headers: bearer(secrets.apiKey) });
+    const skip = Promise.resolve(void 0);
+    const [balance, accountRes, endpoints, undelivered, disputeList] = await Promise.all([
+      get("/balance"),
+      account ? get("/account") : skip,
+      webhooks ? get("/webhook_endpoints?limit=100") : skip,
+      webhooks ? get(`/events?delivery_success=false&limit=100&created[gte]=${Math.floor(now / 1e3) - DAY_S}`) : skip,
+      disputes ? get("/disputes?limit=100") : skip
+    ]);
+    if (!balance.ok && balance.status !== 403) return balance.outcome;
+    const metrics = {};
+    const warnings = [];
+    const funds = balance.ok ? balance.json : void 0;
+    if (funds) {
+      metrics.mode = funds.livemode ? "live" : "test";
+      if (funds.available?.length) metrics.available = money(funds.available);
+      if (funds.pending?.length) metrics.pending = money(funds.pending);
+    } else {
+      metrics.key = "restricted";
+    }
+    if (accountRes?.ok && funds?.livemode) {
+      const body = accountRes.json;
+      if (body.charges_enabled === false) warnings.push("Charges are disabled");
+      if (body.payouts_enabled === false) warnings.push("Payouts are disabled");
+      const overdue = body.requirements?.past_due?.length ?? 0;
+      if (overdue > 0) warnings.push(`${overdue} account requirement(s) past due`);
+    }
+    let instances;
+    if (endpoints?.ok) {
+      const list = endpoints.json.data ?? [];
+      const seen = /* @__PURE__ */ new Set();
+      instances = list.map((endpoint) => {
+        let key = endpointKey(endpoint.url);
+        for (let n = 2; seen.has(key); n++) key = `${endpointKey(endpoint.url)}#${n}`;
+        seen.add(key);
+        const enabled = endpoint.status === "enabled";
+        return { key, id: endpoint.id, state: endpoint.status, status: enabled ? "up" : "down", error: enabled ? void 0 : "Endpoint disabled" };
+      });
+      metrics.webhookEndpoints = list.length;
+      const disabled = instances.filter((instance2) => instance2.status === "down").length;
+      if (disabled > 0) warnings.push(`${disabled} webhook endpoint(s) disabled`);
+    }
+    if (undelivered?.ok) {
+      const list = undelivered.json;
+      metrics.undelivered24h = count(list);
+      if (list.data?.length) warnings.push(`${count(list)} event(s) not delivered in the last 24 h`);
+    }
+    if (disputeList?.ok) {
+      const open = (disputeList.json.data ?? []).filter(
+        (dispute) => dispute.status.endsWith("needs_response")
+      );
+      metrics.openDisputes = open.length;
+    }
+    return {
+      status: warnings.length ? "degraded" : "up",
+      latencyMs: balance.latencyMs,
+      httpStatus: balance.status,
+      error: warnings.join("; ") || void 0,
+      metrics,
+      instances: instances?.length ? instances : void 0,
+      instanceLabels: { key: "Webhook endpoint", detail: "ID" }
+    };
+  }
+});
+
+// src/presets/providers/search.ts
+var exa = definePreset()({
+  kind: "exa",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Exa", identity: "exa", description: "Validates the API key (no search is run)" }),
+  check: async ({ secrets, http }) => keyAccepted(await http("https://api.exa.ai/search", emptyPost({ "x-api-key": secrets.apiKey })))
+});
+var nimble = definePreset()({
+  kind: "nimble",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Nimble", identity: "nimble", description: "Validates the API key (no search is run)" }),
+  check: async ({ secrets, http }) => keyAccepted(await http("https://sdk.nimbleway.com/v1/search", emptyPost(bearer(secrets.apiKey))))
+});
+var tavily = definePreset()({
+  kind: "tavily",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Tavily", identity: "tavily", description: "Reads the credits used this period" }),
+  check: async ({ options, secrets, http }) => {
+    const res = await http("https://api.tavily.com/usage", { headers: bearer(secrets.apiKey) });
+    if (!res.ok) return res.outcome;
+    const { key, account } = res.json ?? {};
+    const metrics = account?.current_plan ? { plan: account.current_plan } : void 0;
+    const [used, limit] = key?.limit ? [key.usage, key.limit] : [account?.plan_usage, account?.plan_limit];
+    if (typeof used !== "number" || !limit) return { ...res.outcome, metrics };
+    return {
+      ...res.outcome,
+      ...quota({
+        label: "Credits",
+        used,
+        limit,
+        unit: "credits",
+        warnAbovePct: options.track?.quota?.warnAbovePct ?? 90,
+        warning: "Credits almost exhausted"
+      }),
+      metrics
+    };
+  }
+});
+var emelia = definePreset()({
+  kind: "emelia",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Emelia", identity: "emelia", description: "Validates the API key (no lookup is run)" }),
+  check: async ({ options, secrets, http }) => keyAccepted(
+    await http(
+      `${(options.baseUrl ?? "https://api.emelia.io").replace(/\/+$/, "")}/tools/find/email`,
+      // Emelia takes the bare key, without a scheme
+      emptyPost({ Authorization: secrets.apiKey })
+    )
+  )
+});
+
+export { anthropic, attendee, aws, axiom, azureTranslator, cambai, clearGoogleTokens, cloudflareStream, crashReason, deepgram, deepl, elevenlabs, emelia, exa, fly, gcp, gemini, github, gladia, googleServiceAccountToken, googleTranslate, mailersend, meilisearch, mongodb, mux, neon, nimble, openai, parseServiceAccount, postgres, pusher, redis, resend, revolut, signGoogleAssertion, signPusherRequest, speechmatics, statuspage, stripe, tavily, upstashRedis, vercel };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map