@agent-native/core 0.137.8 → 0.139.0

package/dist/db/migrations.js

@@ -240,6 +240,11 @@ export function runMigrations(migrations, options) {
             seenNames.add(m.name);
         }
     }
+    // A plugin with no migrations is intentionally a no-op. Creating or reading
+    // a bookkeeping table here turns an empty app plugin into a database cold
+    // start on every serverless boot.
+    if (migrations.length === 0)
+        return async () => { };
     const namedTable = `${table}_named`;
     return async () => {
         try {

package/dist/eject/provider-api-definitions.d.ts

@@ -6,7 +6,7 @@ export declare function mergeProviderApiConfigs(overrides?: readonly ProviderApi
 export declare function getProviderApiConfig(providerId: ProviderApiId | string, overrides?: readonly ProviderApiConfig[]): ProviderApiConfig;
 export declare function listProviderApiIdsForTemplateUse(templateUse: WorkspaceConnectionTemplateUse, overrides?: readonly ProviderApiConfig[]): ProviderApiId[];
 export declare function listProviderApiCatalog(providerId?: ProviderApiId | string, options?: Parameters<typeof listRuntimeProviderApiCatalog>[1]): {
-    id: "amplitude" | "apollo" | "bigquery" | "clay" | "commonroom" | "dataforseo" | "figma" | "ga4" | "gcloud" | "github" | "gmail" | "gong" | "google_calendar" | "google_drive" | "google_slides" | "grafana" | "granola" | "hubspot" | "jira" | "mixpanel" | "notion" | "posthog" | "prometheus" | "pylon" | "salesforce" | "sentry" | "slack" | "stripe" | "twitter";
+    id: "amplitude" | "apollo" | "bigquery" | "clay" | "commonroom" | "dataforseo" | "figma" | "fullstory" | "ga4" | "gcloud" | "github" | "gmail" | "gong" | "google_calendar" | "google_drive" | "google_slides" | "grafana" | "granola" | "hubspot" | "jira" | "mixpanel" | "notion" | "posthog" | "prometheus" | "pylon" | "salesforce" | "sentry" | "slack" | "stripe" | "twitter";
     label: string;
     defaultBaseUrl: string;
     requiresConnectionId: boolean;

package/dist/eject/provider-api-definitions.js

@@ -14,6 +14,7 @@ export const providerApiOverrides = [
     provider("gcloud"),
     provider("github"),
     provider("figma"),
+    provider("fullstory"),
     provider("gmail"),
     provider("gong"),
     provider("google_calendar"),

package/dist/eject/remote-mcp-presets.js

@@ -38,6 +38,7 @@ function preset(id) {
 export const DEFAULT_MCP_INTEGRATIONS = [
     preset("context7"),
     preset("sentry"),
+    preset("fullstory"),
     preset("notion"),
     preset("granola"),
     preset("semgrep"),

package/dist/email-catalog/actions/list-email-activity.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    templateId: string;
+    limit?: unknown;
+}, import("../provider-metrics.js").ProviderMetricsResult<import("../provider-metrics.js").EmailActivityEntry[]>>;
+export default _default;
+//# sourceMappingURL=list-email-activity.d.ts.map

package/dist/email-catalog/actions/list-email-activity.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { authorizeTransactionalEmailRead } from "../authorize.js";
+import { fetchEmailActivity } from "../provider-metrics.js";
+export default defineAction({
+    description: "List recent provider activity for one registered transactional email in this app. Organization admin only.",
+    schema: z.object({
+        templateId: z.string().min(1),
+        limit: z.coerce.number().int().min(1).max(1000).default(50),
+    }),
+    http: { method: "GET" },
+    authorize: ({ templateId }) => authorizeTransactionalEmailRead([templateId]),
+    run: async ({ templateId, limit }) => fetchEmailActivity({ templateId, limit }),
+});
+//# sourceMappingURL=list-email-activity.js.map

package/dist/email-catalog/actions/list-email-engagement.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    templateIds: string[];
+    windowDays?: unknown;
+}, import("../provider-metrics.js").ProviderMetricsResult<import("../provider-metrics.js").EmailEngagement[]>>;
+export default _default;
+//# sourceMappingURL=list-email-engagement.d.ts.map

package/dist/email-catalog/actions/list-email-engagement.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { authorizeTransactionalEmailRead } from "../authorize.js";
+import { fetchEmailEngagement } from "../provider-metrics.js";
+export default defineAction({
+    description: "Read provider engagement metrics for registered transactional emails in this app. Organization admin only.",
+    schema: z.object({
+        templateIds: z.array(z.string().min(1)).max(100),
+        windowDays: z.coerce.number().int().min(1).max(365).default(30),
+    }),
+    http: { method: "POST" },
+    authorize: ({ templateIds }) => authorizeTransactionalEmailRead(templateIds),
+    run: async ({ templateIds, windowDays }) => fetchEmailEngagement(templateIds, windowDays),
+});
+//# sourceMappingURL=list-email-engagement.js.map

package/dist/email-catalog/actions/list-email-log.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    templateId?: string;
+    limit?: unknown;
+}, {
+    entries: import("../log.js").EmailLogEntry[];
+}>;
+export default _default;
+//# sourceMappingURL=list-email-log.d.ts.map

package/dist/email-catalog/actions/list-email-log.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { getAppSlug } from "../../server/app-name.js";
+import { authorizeTransactionalEmailRead } from "../authorize.js";
+import { listEmailLog } from "../log.js";
+export default defineAction({
+    description: "List recent transactional email sends from this app, newest first, optionally filtered to one registered email id.",
+    schema: z.object({
+        templateId: z.string().optional(),
+        limit: z.coerce.number().int().min(1).max(500).default(100),
+    }),
+    http: { method: "GET" },
+    authorize: ({ templateId }) => authorizeTransactionalEmailRead(templateId ? [templateId] : []),
+    run: async ({ templateId, limit }) => ({
+        entries: await listEmailLog({
+            app: getAppSlug() ?? "unknown",
+            templateId,
+            limit,
+        }),
+    }),
+});
+//# sourceMappingURL=list-email-log.js.map

package/dist/email-catalog/actions/list-transactional-emails.d.ts

@@ -0,0 +1,23 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    windowDays?: unknown;
+}, {
+    app: string;
+    windowDays: number;
+    statsAvailable: boolean;
+    statsError: string;
+    emails: {
+        id: string;
+        app: string;
+        name: string;
+        trigger: string;
+        recipient: string;
+        recipientLabel: string;
+        sender: string;
+        senderLabel: string;
+        sent: number;
+        failed: number;
+        lastSentAt: number;
+    }[];
+}>;
+export default _default;
+//# sourceMappingURL=list-transactional-emails.d.ts.map

package/dist/email-catalog/actions/list-transactional-emails.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { getAppSlug } from "../../server/app-name.js";
+import { getEmailSendStats } from "../log.js";
+import { listTransactionalEmails } from "../registry.js";
+import { registerCoreSystemEmails } from "../system-emails.js";
+const DEFAULT_WINDOW_DAYS = 30;
+export default defineAction({
+    description: "List the transactional emails this app can send, with the trigger, recipient and sender logic for each, plus local send counts and last-sent. Engagement metrics such as open rate are not included here — they live at the email provider.",
+    schema: z.object({
+        windowDays: z.coerce
+            .number()
+            .int()
+            .min(1)
+            .max(365)
+            .default(DEFAULT_WINDOW_DAYS)
+            .describe("How many days of send history to summarize."),
+    }),
+    http: { method: "GET" },
+    run: async ({ windowDays }) => {
+        registerCoreSystemEmails();
+        const since = Date.now() - windowDays * 24 * 60 * 60 * 1000;
+        const app = getAppSlug() ?? "unknown";
+        const definitions = listTransactionalEmails();
+        // A failed stats read must not masquerade as "no email ever sent" — the
+        // catalog is still worth returning, but the caller has to be able to tell
+        // that the numbers are missing rather than zero.
+        let statsById = null;
+        let statsError = null;
+        try {
+            const stats = await getEmailSendStats(since, app);
+            statsById = new Map(stats.map((row) => [row.templateId, row]));
+        }
+        catch (error) {
+            statsError = error instanceof Error ? error.message : String(error);
+        }
+        return {
+            app,
+            windowDays,
+            statsAvailable: statsError === null,
+            statsError,
+            emails: definitions.map((definition) => {
+                const stats = statsById?.get(definition.id);
+                return {
+                    id: definition.id,
+                    app: definition.app,
+                    name: definition.name,
+                    trigger: definition.trigger,
+                    recipient: definition.recipient,
+                    recipientLabel: definition.recipientLabel,
+                    sender: definition.sender,
+                    senderLabel: definition.senderLabel,
+                    sent: stats?.sent ?? (statsById ? 0 : null),
+                    failed: stats?.failed ?? (statsById ? 0 : null),
+                    lastSentAt: stats?.lastSentAt ?? null,
+                };
+            }),
+        };
+    },
+});
+//# sourceMappingURL=list-transactional-emails.js.map

package/dist/email-catalog/actions/render-transactional-email-preview.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    id: string;
+}, {
+    id: string;
+    subject: string;
+    html: string;
+    text: string;
+}>;
+export default _default;
+//# sourceMappingURL=render-transactional-email-preview.d.ts.map

package/dist/email-catalog/actions/render-transactional-email-preview.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { renderTransactionalEmailPreview } from "../registry.js";
+import { registerCoreSystemEmails } from "../system-emails.js";
+export default defineAction({
+    description: "Render one of this app's transactional emails with representative dummy data, returning the subject, HTML and plain-text bodies for preview.",
+    schema: z.object({
+        id: z
+            .string()
+            .describe("Registered email id, e.g. calendar.booking-confirmed."),
+    }),
+    http: { method: "GET" },
+    run: async ({ id }) => {
+        registerCoreSystemEmails();
+        const rendered = renderTransactionalEmailPreview(id);
+        return {
+            id,
+            subject: rendered.subject,
+            html: rendered.html,
+            text: rendered.text,
+        };
+    },
+});
+//# sourceMappingURL=render-transactional-email-preview.js.map

package/dist/email-catalog/authorize.d.ts

@@ -0,0 +1,2 @@
+export declare function authorizeTransactionalEmailRead(templateIds?: string[]): Promise<boolean>;
+//# sourceMappingURL=authorize.d.ts.map

package/dist/email-catalog/authorize.js

@@ -0,0 +1,10 @@
+import { currentRequestUserIsOrgAdmin } from "../server/org-admin.js";
+import { getTransactionalEmail } from "./registry.js";
+import { registerCoreSystemEmails } from "./system-emails.js";
+export async function authorizeTransactionalEmailRead(templateIds = []) {
+    if (!(await currentRequestUserIsOrgAdmin()))
+        return false;
+    registerCoreSystemEmails();
+    return templateIds.every((id) => Boolean(getTransactionalEmail(id)));
+}
+//# sourceMappingURL=authorize.js.map

package/dist/email-catalog/log.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Durable send log for transactional emails.
+ *
+ * Written by `sendEmail` on every attempt, successful or not. Read by Dispatch
+ * to report per-email send counts and last-sent without depending on the
+ * provider's activity retention window.
+ */
+export interface RecordEmailSendArgs {
+    templateId?: string;
+    app?: string;
+    recipient: string;
+    sender: string;
+    subject: string;
+    status: "sent" | "failed";
+    error?: string;
+    provider: string;
+}
+/**
+ * Append one send record.
+ *
+ * Callers treat logging as best-effort: a logging failure must not turn a
+ * delivered email into a thrown send. The failure is surfaced on the console
+ * rather than swallowed, so a persistently broken log is visible instead of
+ * quietly producing an empty activity view.
+ */
+export declare function recordEmailSend(args: RecordEmailSendArgs): Promise<void>;
+export interface EmailSendStats {
+    templateId: string;
+    sent: number;
+    failed: number;
+    lastSentAt: number | null;
+}
+/**
+ * Per-template send counts and last-sent, for sends at or after `since`.
+ * Templates with no rows are absent from the result — callers distinguish
+ * "never sent" from "sent zero times in window" by that absence.
+ */
+export declare function getEmailSendStats(since: number, app: string): Promise<EmailSendStats[]>;
+export interface EmailLogEntry {
+    id: string;
+    templateId: string | null;
+    app: string | null;
+    recipient: string;
+    sender: string;
+    subject: string;
+    status: string;
+    error: string | null;
+    provider: string;
+    createdAt: number;
+}
+/** Most recent sends for one app, newest first, optionally filtered to one template. */
+export declare function listEmailLog(options: {
+    app: string;
+    templateId?: string;
+    limit?: number;
+}): Promise<EmailLogEntry[]>;
+//# sourceMappingURL=log.d.ts.map

package/dist/email-catalog/log.js

@@ -0,0 +1,117 @@
+/**
+ * Durable send log for transactional emails.
+ *
+ * Written by `sendEmail` on every attempt, successful or not. Read by Dispatch
+ * to report per-email send counts and last-sent without depending on the
+ * provider's activity retention window.
+ */
+import { randomUUID } from "node:crypto";
+import { getDbExec, isPostgres } from "../db/client.js";
+import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
+let _initPromise;
+async function ensureTable() {
+    if (!_initPromise) {
+        _initPromise = (async () => {
+            const { EMAIL_LOG_CREATE_SQL, EMAIL_LOG_TEMPLATE_INDEX_SQL } = await import("./schema.js");
+            // Generic INTEGER maps to BIGINT on Postgres, which millisecond
+            // timestamps need.
+            const createSql = isPostgres()
+                ? EMAIL_LOG_CREATE_SQL.replace(/\bINTEGER\b/g, "BIGINT")
+                : EMAIL_LOG_CREATE_SQL;
+            await ensureTableExists("email_log", createSql);
+            await ensureIndexExists("email_log_template_created_idx", EMAIL_LOG_TEMPLATE_INDEX_SQL);
+        })().catch((error) => {
+            // Don't memoize a failed bootstrap — the next send should retry rather
+            // than log nothing forever.
+            _initPromise = undefined;
+            throw error;
+        });
+    }
+    return _initPromise;
+}
+/**
+ * Append one send record.
+ *
+ * Callers treat logging as best-effort: a logging failure must not turn a
+ * delivered email into a thrown send. The failure is surfaced on the console
+ * rather than swallowed, so a persistently broken log is visible instead of
+ * quietly producing an empty activity view.
+ */
+export async function recordEmailSend(args) {
+    try {
+        await ensureTable();
+        await getDbExec().execute({
+            sql: `INSERT INTO email_log
+        (id, template_id, app, recipient, sender, subject, status, error, provider, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            args: [
+                randomUUID(),
+                args.templateId ?? null,
+                args.app ?? null,
+                args.recipient,
+                args.sender,
+                args.subject,
+                args.status,
+                args.error ?? null,
+                args.provider,
+                Date.now(),
+            ],
+        });
+    }
+    catch (error) {
+        console.error("[agent-native:email] failed to record send", error);
+    }
+}
+/**
+ * Per-template send counts and last-sent, for sends at or after `since`.
+ * Templates with no rows are absent from the result — callers distinguish
+ * "never sent" from "sent zero times in window" by that absence.
+ */
+export async function getEmailSendStats(since, app) {
+    await ensureTable();
+    const { rows } = await getDbExec().execute({
+        sql: `SELECT template_id,
+        SUM(CASE WHEN status = 'sent' THEN 1 ELSE 0 END) AS sent,
+        SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) AS failed,
+        MAX(CASE WHEN status = 'sent' THEN created_at END) AS last_sent_at
+      FROM email_log
+      WHERE app = ? AND template_id IS NOT NULL AND created_at >= ?
+      GROUP BY template_id`,
+        args: [app, since],
+    });
+    return rows.map((row) => ({
+        templateId: String(row.template_id),
+        sent: Number(row.sent ?? 0),
+        failed: Number(row.failed ?? 0),
+        lastSentAt: row.last_sent_at == null ? null : Number(row.last_sent_at),
+    }));
+}
+/** Most recent sends for one app, newest first, optionally filtered to one template. */
+export async function listEmailLog(options) {
+    await ensureTable();
+    const limit = Math.min(Math.max(options.limit ?? 100, 1), 500);
+    const where = options.templateId
+        ? `WHERE app = ? AND template_id = ?`
+        : `WHERE app = ?`;
+    const args = options.templateId
+        ? [options.app, options.templateId, limit]
+        : [options.app, limit];
+    const { rows } = await getDbExec().execute({
+        sql: `SELECT id, template_id, app, recipient, sender, subject, status, error, provider, created_at
+      FROM email_log ${where} ORDER BY created_at DESC LIMIT ?`,
+        args,
+    });
+    return rows.map((row) => ({
+        id: String(row.id),
+        templateId: row.template_id == null ? null : String(row.template_id),
+        app: row.app == null ? null : String(row.app),
+        recipient: String(row.recipient),
+        sender: String(row.sender),
+        subject: String(row.subject),
+        status: String(row.status),
+        error: row.error == null ? null : String(row.error),
+        provider: String(row.provider),
+        createdAt: Number(row.created_at),
+    }));
+}
+//# sourceMappingURL=log.js.map

package/dist/email-catalog/provider-metrics.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Engagement metrics and activity for registered transactional emails, read
+ * from the active provider in the current app's request context.
+ */
+export type ProviderMetricsResult<T> = {
+    available: true;
+    data: T;
+} | {
+    available: false;
+    reason: string;
+};
+export interface EmailEngagement {
+    templateId: string;
+    delivered: number;
+    uniqueOpens: number;
+    uniqueClicks: number;
+    openRate: number | null;
+}
+export declare function fetchEmailEngagement(templateIds: string[], windowDays: number): Promise<ProviderMetricsResult<EmailEngagement[]>>;
+export interface EmailActivityEntry {
+    msgId: string;
+    toEmail: string;
+    fromEmail: string;
+    subject: string;
+    status: string;
+    opensCount: number;
+    clicksCount: number;
+    lastEventTime: string;
+}
+export declare function fetchEmailActivity(options: {
+    templateId: string;
+    limit?: number;
+}): Promise<ProviderMetricsResult<EmailActivityEntry[]>>;
+//# sourceMappingURL=provider-metrics.d.ts.map

package/dist/email-catalog/provider-metrics.js

@@ -0,0 +1,165 @@
+/**
+ * Engagement metrics and activity for registered transactional emails, read
+ * from the active provider in the current app's request context.
+ */
+import { z } from "zod";
+import { resolveSecret } from "../server/credential-provider.js";
+import { getEmailProvider } from "../server/email.js";
+const SENDGRID_API = "https://api.sendgrid.com/v3";
+const SENDGRID_PAGE_SIZE = 1000;
+const SENDGRID_MAX_PAGES = 10;
+const categoryMetricsSchema = z
+    .object({
+    delivered: z.number().default(0),
+    unique_opens: z.number().default(0),
+    unique_clicks: z.number().default(0),
+})
+    .passthrough();
+const categoryStatSchema = z
+    .object({
+    name: z.string(),
+    metrics: categoryMetricsSchema.default(() => ({
+        delivered: 0,
+        unique_opens: 0,
+        unique_clicks: 0,
+    })),
+})
+    .passthrough();
+const categorySumsSchema = z.object({
+    stats: z.array(categoryStatSchema).default([]),
+});
+const activitySchema = z.object({
+    messages: z
+        .array(z
+        .object({
+        msg_id: z.string().default(""),
+        to_email: z.string().default(""),
+        from_email: z.string().default(""),
+        subject: z.string().default(""),
+        status: z.string().default(""),
+        opens_count: z.coerce.number().default(0),
+        clicks_count: z.coerce.number().default(0),
+        last_event_time: z.string().default(""),
+    })
+        .passthrough())
+        .default([]),
+});
+async function activeSendGrid() {
+    const provider = await getEmailProvider();
+    if (provider === "resend") {
+        return {
+            available: false,
+            reason: "Email delivery uses Resend, so SendGrid metrics do not describe the active transport.",
+        };
+    }
+    if (provider !== "sendgrid") {
+        return {
+            available: false,
+            reason: "No email provider is configured, so provider metrics cannot be read.",
+        };
+    }
+    const key = await resolveSecret("SENDGRID_API_KEY");
+    if (!key) {
+        return {
+            available: false,
+            reason: "SendGrid is the active email transport, but SENDGRID_API_KEY could not be resolved.",
+        };
+    }
+    return { available: true, key };
+}
+function isoDate(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+async function sendgridGet(key, path, params) {
+    const url = new URL(`${SENDGRID_API}${path}`);
+    for (const [name, value] of params)
+        url.searchParams.append(name, value);
+    const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    if (!res.ok) {
+        const body = await res
+            .text()
+            .catch((cause) => `<error body unreadable: ${cause}>`);
+        throw new Error(`SendGrid ${res.status} on ${path}: ${body.slice(0, 300)}`);
+    }
+    return res.json();
+}
+export async function fetchEmailEngagement(templateIds, windowDays) {
+    if (!templateIds.length)
+        return { available: true, data: [] };
+    const sendgrid = await activeSendGrid();
+    if (!sendgrid.available)
+        return sendgrid;
+    const end = Date.now();
+    const start = end - windowDays * 24 * 60 * 60 * 1000;
+    const requested = new Set(templateIds);
+    const data = [];
+    try {
+        for (let page = 0; page < SENDGRID_MAX_PAGES; page += 1) {
+            const payload = categorySumsSchema.parse(await sendgridGet(sendgrid.key, "/categories/stats/sums", [
+                ["start_date", isoDate(start)],
+                ["end_date", isoDate(end)],
+                ["limit", String(SENDGRID_PAGE_SIZE)],
+                ["offset", String(page * SENDGRID_PAGE_SIZE)],
+            ]));
+            for (const entry of payload.stats) {
+                if (!requested.has(entry.name))
+                    continue;
+                requested.delete(entry.name);
+                const delivered = entry.metrics.delivered;
+                const uniqueOpens = entry.metrics.unique_opens;
+                data.push({
+                    templateId: entry.name,
+                    delivered,
+                    uniqueOpens,
+                    uniqueClicks: entry.metrics.unique_clicks,
+                    openRate: delivered > 0 ? Math.min(uniqueOpens / delivered, 1) : null,
+                });
+            }
+            if (requested.size === 0 || payload.stats.length < SENDGRID_PAGE_SIZE) {
+                break;
+            }
+        }
+        return { available: true, data };
+    }
+    catch (error) {
+        return {
+            available: false,
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function fetchEmailActivity(options) {
+    const sendgrid = await activeSendGrid();
+    if (!sendgrid.available)
+        return sendgrid;
+    const limit = Math.min(Math.max(options.limit ?? 50, 1), 1000);
+    const safe = options.templateId.replace(/["\\]/g, "");
+    try {
+        const payload = activitySchema.parse(await sendgridGet(sendgrid.key, "/messages", [
+            ["limit", String(limit)],
+            ["query", `category="${safe}"`],
+        ]));
+        return {
+            available: true,
+            data: payload.messages.map((message) => ({
+                msgId: message.msg_id,
+                toEmail: message.to_email,
+                fromEmail: message.from_email,
+                subject: message.subject,
+                status: message.status,
+                opensCount: message.opens_count,
+                clicksCount: message.clicks_count,
+                lastEventTime: message.last_event_time,
+            })),
+        };
+    }
+    catch (error) {
+        return {
+            available: false,
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=provider-metrics.js.map