@agent-native/core 0.176.4-nightly-20260902024948 → 0.176.4-nightly-20260902074703

package/dist/agent/chat-health-alert.d.ts

@@ -18,6 +18,12 @@ export type ChatHealthAlertOutcome = {
     turns: number;
     badRate: number;
     recipients: number;
+} | {
+    status: "delivery-failed";
+    reason: string;
+} | {
+    status: "persistence-failed";
+    reason: string;
 } | {
     status: "check-failed";
     reason: string;

package/dist/agent/chat-health-alert.js

@@ -1,8 +1,10 @@
+import { randomUUID } from "node:crypto";
 import { getDbExec } from "../db/client.js";
-import { notify } from "../notifications/registry.js";
-import { getSetting, putSetting } from "../settings/store.js";
+import { notifyWithDelivery } from "../notifications/registry.js";
+import { runWithRequestContext } from "../server/request-context.js";
+import { deleteSettingIfValue, mutateSetting } from "../settings/store.js";
 /**
- * Pages the people who can act when an app's chat stops answering.
+ * Sends one Slack alert when an app's chat stops answering.
  *
  * The detector for this already existed as `scripts/chat-health.mjs --strict`,
  * correctly calibrated and exiting 1 on a partial outage — but nothing ever ran
@@ -27,7 +29,9 @@ const MIN_TURNS = 5;
 const BAD_RATE_THRESHOLD = 0.5;
 /** One page per outage, not one per sweep. */
 const COOLDOWN_MS = 60 * 60_000;
-const LAST_ALERT_SETTING_KEY = "chat-health-alert:last-paged-at";
+/** Slack sends time out well inside this lease; failed sends release it early. */
+const CLAIM_LEASE_MS = 5 * 60_000;
+const LAST_ALERT_SETTING_KEY = "chat-health-alert:last-slack-alert-at";
 /**
  * Scores the LAST run of each turn in the window, matching how
  * `scripts/chat-health.mjs` reports so a page and the CLI never disagree.
@@ -57,16 +61,38 @@ async function countRecentTurns(since) {
         bad: Number(row?.bad ?? 0),
     };
 }
-/** Owners and admins — the people who can actually change a model or a key. */
-async function alertRecipients() {
+/** Use one owner/admin only when the app has an unambiguous org scope. */
+async function alertOwner() {
     const { rows } = await getDbExec().execute({
-        sql: `SELECT DISTINCT email FROM org_members
-          WHERE role IN ('owner', 'admin')`,
+        sql: `SELECT org_id, email, role FROM org_members
+          WHERE role IN ('owner', 'admin')
+          ORDER BY CASE role WHEN 'owner' THEN 0 WHEN 'admin' THEN 1 ELSE 2 END, email`,
         args: [],
     });
-    return rows
-        .map((r) => String(r.email ?? ""))
-        .filter(Boolean);
+    const orgIds = new Set(rows.map((row) => String(row.org_id ?? "")));
+    if (orgIds.size !== 1 || orgIds.has(""))
+        return null;
+    const recipient = rows.find((row) => {
+        const role = row.role;
+        return role === "owner" || role === "admin";
+    });
+    const email = String(recipient?.email ?? "");
+    const [orgId] = [...orgIds];
+    return email && orgId ? { owner: email, orgId } : null;
+}
+async function releaseAlertClaim(claimId, claimExpiresAt) {
+    try {
+        await deleteSettingIfValue(LAST_ALERT_SETTING_KEY, {
+            claimId,
+            claimExpiresAt,
+        });
+        return null;
+    }
+    catch (error) {
+        const reason = "The Slack alert claim could not be released.";
+        console.error(`[chat-health-alert] ${reason}`, error);
+        return reason;
+    }
 }
 export async function checkChatHealthAndAlert(now = Date.now()) {
     let counts;
@@ -84,58 +110,116 @@ export async function checkChatHealthAndAlert(now = Date.now()) {
     if (badRate < BAD_RATE_THRESHOLD) {
         return { status: "healthy", turns: counts.turns, badRate };
     }
-    // A cooldown stamp we could not READ is not a cooldown that is absent:
-    // treating it as absent pages on every sweep for as long as settings stay
-    // unreadable, which is exactly the spam the cooldown exists to prevent.
-    let stored;
+    // Claim the page before awaiting the external send. The short lease keeps
+    // overlapping sweeps from both sending; failed sends release it below,
+    // while a crashed send becomes retryable after the lease.
+    const claimId = randomUUID();
+    const claimExpiresAt = now + CLAIM_LEASE_MS;
+    let claim;
     try {
-        stored = (await getSetting(LAST_ALERT_SETTING_KEY));
+        claim = await mutateSetting(LAST_ALERT_SETTING_KEY, (current) => {
+            const lastPagedAt = Number(current?.at ?? 0);
+            const existingClaimExpiresAt = Number(current?.claimExpiresAt ?? 0);
+            if ((Number.isFinite(lastPagedAt) && now - lastPagedAt < COOLDOWN_MS) ||
+                (Number.isFinite(existingClaimExpiresAt) &&
+                    existingClaimExpiresAt > now)) {
+                return current ?? {};
+            }
+            return { claimId, claimExpiresAt };
+        });
     }
     catch (error) {
         return { status: "check-failed", reason: String(error) };
     }
-    const lastPagedAt = Number(stored?.at ?? 0);
-    if (Number.isFinite(lastPagedAt) && now - lastPagedAt < COOLDOWN_MS) {
+    if (String(claim.claimId ?? "") !== claimId) {
+        const lastPagedAt = Number(claim.at ?? 0);
+        const retryAfterMs = Number.isFinite(lastPagedAt) && now - lastPagedAt < COOLDOWN_MS
+            ? COOLDOWN_MS - (now - lastPagedAt)
+            : Math.max(0, Number(claim.claimExpiresAt ?? 0) - now);
         return {
             status: "cooldown",
-            retryAfterMs: COOLDOWN_MS - (now - lastPagedAt),
+            retryAfterMs,
         };
     }
-    let recipients;
+    let recipient;
     try {
-        recipients = await alertRecipients();
+        recipient = await alertOwner();
     }
     catch (error) {
-        return { status: "check-failed", reason: String(error) };
+        const releaseReason = await releaseAlertClaim(claimId, claimExpiresAt);
+        return {
+            status: "check-failed",
+            reason: releaseReason
+                ? `${String(error)} ${releaseReason}`
+                : String(error),
+        };
+    }
+    if (!recipient) {
+        const reason = "No single owner/admin organization scope is available for Slack health alerts.";
+        const releaseReason = await releaseAlertClaim(claimId, claimExpiresAt);
+        return {
+            status: "delivery-failed",
+            reason: releaseReason ? `${reason} ${releaseReason}` : reason,
+        };
     }
     const pct = Math.round(badRate * 100);
-    for (const owner of recipients) {
-        await notify({
+    let delivery;
+    try {
+        delivery = await runWithRequestContext({ userEmail: recipient.owner, orgId: recipient.orgId }, () => notifyWithDelivery({
             severity: "critical",
             title: `Chat is failing: ${pct}% of turns ended without an answer`,
             body: `${counts.bad} of ${counts.turns} turns in the last hour ended without ` +
                 `an answer. Run \`node scripts/chat-health.mjs --hours 1\` for the ` +
                 `per-reason breakdown.`,
+            channels: ["slack"],
             metadata: {
                 turns: counts.turns,
                 bad: counts.bad,
                 badRate,
                 windowMs: WINDOW_MS,
             },
-        }, { owner }).catch((error) => {
-            // One undeliverable recipient must not suppress the rest.
-            console.error("[chat-health-alert] notify failed for a recipient:", error);
-        });
+        }, { owner: recipient.owner }));
+    }
+    catch (error) {
+        console.error("[chat-health-alert] Slack delivery failed:", error);
+        const releaseReason = await releaseAlertClaim(claimId, claimExpiresAt);
+        return {
+            status: "delivery-failed",
+            reason: releaseReason
+                ? `${String(error)} ${releaseReason}`
+                : String(error),
+        };
+    }
+    if (!delivery.deliveredChannels.includes("slack")) {
+        const reason = "Slack health alert was not delivered.";
+        console.error(`[chat-health-alert] ${reason}`);
+        const releaseReason = await releaseAlertClaim(claimId, claimExpiresAt);
+        return {
+            status: "delivery-failed",
+            reason: releaseReason ? `${reason} ${releaseReason}` : reason,
+        };
+    }
+    // Finalize only after Slack confirms delivery. The claim id keeps a slow or
+    // expired sender from overwriting a newer claim's cooldown.
+    try {
+        const finalized = await mutateSetting(LAST_ALERT_SETTING_KEY, (current) => String(current?.claimId ?? "") === claimId
+            ? { at: now, claimId }
+            : (current ?? {}));
+        if (String(finalized.claimId ?? "") !== claimId) {
+            const reason = "Slack delivered, but its alert cooldown claim was lost before persistence.";
+            console.error(`[chat-health-alert] ${reason}`);
+            return { status: "persistence-failed", reason };
+        }
     }
-    // Stamped only after an attempt was actually made, so a failed page retries
-    // on the next sweep instead of being silenced by its own cooldown.
-    await putSetting(LAST_ALERT_SETTING_KEY, { at: now }).catch((error) => {
+    catch (error) {
+        const reason = "Slack delivered, but the alert cooldown could not be persisted.";
         console.error("[chat-health-alert] could not stamp cooldown:", error);
-    });
+        return { status: "persistence-failed", reason };
+    }
     return {
         status: "alerted",
         turns: counts.turns,
         badRate,
-        recipients: recipients.length,
+        recipients: 1,
     };
 }

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -3,18 +3,18 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url?: string;
     filename?: string;
 }, {
-    id?: undefined;
     error: string;
     configured?: undefined;
     connectPath?: undefined;
     url?: undefined;
+    id?: undefined;
     provider?: undefined;
 } | {
-    id?: undefined;
     error: string;
     configured: boolean;
     connectPath: string;
     url?: undefined;
+    id?: undefined;
     provider?: undefined;
 } | {
     error?: undefined;

package/dist/notifications/channels.js

@@ -32,6 +32,7 @@ import { getKeyAllowlist, getResolvedKeyAllowlist, resolveKeyReferencesWithReque
 import { sendEmail } from "../server/email.js";
 import { registerNotificationChannel } from "./registry.js";
 let _registered = false;
+const SLACK_DELIVERY_TIMEOUT_MS = 10_000;
 export function registerBuiltinNotificationChannels() {
     if (_registered)
         return;
@@ -89,6 +90,7 @@ function createSlackWebhookChannel(envUrlTemplate) {
             const res = await ssrfSafeFetch(url, {
                 method: "POST",
                 headers,
+                signal: AbortSignal.timeout(SLACK_DELIVERY_TIMEOUT_MS),
                 body: JSON.stringify({
                     text: slackText(input.severity, input.title, input.body),
                     blocks: [

package/dist/notifications/routes.d.ts

@@ -11,14 +11,14 @@
  *   DELETE /_agent-native/notifications/:id         — delete
  */
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
-    error?: undefined;
     count: number;
     updated?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     count?: undefined;
     updated: number;
+    error?: undefined;
     ok?: undefined;
 } | {
     count?: undefined;
@@ -26,8 +26,8 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     count?: undefined;
     updated?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/observability/routes.d.ts

@@ -43,8 +43,8 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
 } | {
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
-    id?: undefined;
     error?: undefined;
+    id?: undefined;
     ok?: undefined;
 } | {
     summary?: undefined;
@@ -55,13 +55,13 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
 } | {
     summary?: undefined;
     spans?: undefined;
-    id?: undefined;
     error: any;
+    id?: undefined;
     ok?: undefined;
 } | {
     summary?: undefined;
     spans?: undefined;
-    id?: undefined;
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
+    id?: undefined;
 }>>;

package/dist/resources/handlers.d.ts

@@ -48,8 +48,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
 }>;
 /** DELETE /_agent-native/resources/:id — delete a resource */
 export declare function handleDeleteResource(event: any): Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.176.4-nightly-20260902024948",
+  "version": "0.176.4-nightly-20260902074703",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {