@agent-native/core 0.161.9 → 0.161.12

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

@@ -0,0 +1,25 @@
+/**
+ * Every outcome is distinguishable. "Not enough turns to judge" and "healthy"
+ * are different answers, and a check that could not run is neither — collapsing
+ * them is how a monitor reports all-clear through an outage.
+ */
+export type ChatHealthAlertOutcome = {
+    status: "healthy";
+    turns: number;
+    badRate: number;
+} | {
+    status: "insufficient-data";
+    turns: number;
+} | {
+    status: "cooldown";
+    retryAfterMs: number;
+} | {
+    status: "alerted";
+    turns: number;
+    badRate: number;
+    recipients: number;
+} | {
+    status: "check-failed";
+    reason: string;
+};
+export declare function checkChatHealthAndAlert(now?: number): Promise<ChatHealthAlertOutcome>;

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

@@ -0,0 +1,141 @@
+import { getDbExec } from "../db/client.js";
+import { notify } from "../notifications/registry.js";
+import { getSetting, putSetting } from "../settings/store.js";
+/**
+ * Pages the people who can act 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
+ * it and nothing ever paged, so an app answering 11% of its turns was found by
+ * a user posting in Slack. This is the missing half: the same measurement, on
+ * the durable sweep that already drives stale reaping, scoped to the one app it
+ * runs in so no cross-app credential has to exist anywhere.
+ */
+/** Turns are scored over this window on every sweep. */
+const WINDOW_MS = 60 * 60_000;
+/**
+ * Below this, a rate is noise: one failed turn out of two is 50% and means
+ * nothing. Chat-health's own fleet view showed apps sitting at 100% on a single
+ * turn all day.
+ */
+const MIN_TURNS = 5;
+/**
+ * Deliberately far above `chat-health`'s 0.1 review budget. That threshold
+ * answers "is this app degraded", which is a question for a dashboard. This one
+ * answers "is chat down", which is the only question worth waking someone for.
+ */
+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";
+/**
+ * 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.
+ * User-stopped turns are excluded: someone hitting Stop is not an outage.
+ */
+async function countRecentTurns(since) {
+    const { rows } = await getDbExec().execute({
+        sql: `WITH ranked AS (
+            SELECT turn_id, status,
+                   ROW_NUMBER() OVER (
+                     PARTITION BY turn_id ORDER BY started_at DESC
+                   ) AS rn
+            FROM agent_runs
+            WHERE started_at >= ?
+              AND turn_id IS NOT NULL
+              AND id NOT LIKE 'job-%'
+          )
+          SELECT COUNT(*) AS turns,
+                 SUM(CASE WHEN status = 'errored' THEN 1 ELSE 0 END) AS bad
+          FROM ranked
+          WHERE rn = 1 AND status <> 'aborted'`,
+        args: [since],
+    });
+    const row = rows[0];
+    return {
+        turns: Number(row?.turns ?? 0),
+        bad: Number(row?.bad ?? 0),
+    };
+}
+/** Owners and admins — the people who can actually change a model or a key. */
+async function alertRecipients() {
+    const { rows } = await getDbExec().execute({
+        sql: `SELECT DISTINCT email FROM org_members
+          WHERE role IN ('owner', 'admin')`,
+        args: [],
+    });
+    return rows
+        .map((r) => String(r.email ?? ""))
+        .filter(Boolean);
+}
+export async function checkChatHealthAndAlert(now = Date.now()) {
+    let counts;
+    try {
+        counts = await countRecentTurns(now - WINDOW_MS);
+    }
+    catch (error) {
+        // A check that could not read the ledger has not found the app healthy.
+        return { status: "check-failed", reason: String(error) };
+    }
+    if (counts.turns < MIN_TURNS) {
+        return { status: "insufficient-data", turns: counts.turns };
+    }
+    const badRate = counts.bad / counts.turns;
+    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;
+    try {
+        stored = (await getSetting(LAST_ALERT_SETTING_KEY));
+    }
+    catch (error) {
+        return { status: "check-failed", reason: String(error) };
+    }
+    const lastPagedAt = Number(stored?.at ?? 0);
+    if (Number.isFinite(lastPagedAt) && now - lastPagedAt < COOLDOWN_MS) {
+        return {
+            status: "cooldown",
+            retryAfterMs: COOLDOWN_MS - (now - lastPagedAt),
+        };
+    }
+    let recipients;
+    try {
+        recipients = await alertRecipients();
+    }
+    catch (error) {
+        return { status: "check-failed", reason: String(error) };
+    }
+    const pct = Math.round(badRate * 100);
+    for (const owner of recipients) {
+        await notify({
+            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.`,
+            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);
+        });
+    }
+    // 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) => {
+        console.error("[chat-health-alert] could not stamp cooldown:", error);
+    });
+    return {
+        status: "alerted",
+        turns: counts.turns,
+        badRate,
+        recipients: recipients.length,
+    };
+}

package/dist/client/conversation/use-near-bottom-autoscroll.js

@@ -50,7 +50,27 @@ export function useNearBottomAutoscroll({ followKey, streaming = false, threshol
     const followGenerationRef = useRef(0);
     const lastScrollTopRef = useRef(0);
     const lastTouchYRef = useRef(null);
+    const pendingAnimationFrameIdsRef = useRef(new Set());
+    const pendingTimeoutIdsRef = useRef(new Set());
     const [showScrollToBottom, setShowScrollToBottom] = useState(false);
+    const cancelPendingScrolls = useCallback(() => {
+        for (const id of pendingAnimationFrameIdsRef.current) {
+            window.cancelAnimationFrame(id);
+        }
+        pendingAnimationFrameIdsRef.current.clear();
+        for (const id of pendingTimeoutIdsRef.current) {
+            window.clearTimeout(id);
+        }
+        pendingTimeoutIdsRef.current.clear();
+    }, []);
+    const scheduleAnimationFrame = useCallback((callback) => {
+        let id = 0;
+        id = window.requestAnimationFrame((time) => {
+            pendingAnimationFrameIdsRef.current.delete(id);
+            callback(time);
+        });
+        pendingAnimationFrameIdsRef.current.add(id);
+    }, []);
     const isAtBottom = useCallback((el) => el.scrollHeight - el.scrollTop - el.clientHeight <= threshold, [threshold]);
     const setFollowingBottom = useCallback((following, forceGeneration = false, el) => {
         if (forceGeneration || isNearBottomRef.current !== following) {
@@ -213,14 +233,24 @@ export function useNearBottomAutoscroll({ followKey, streaming = false, threshol
         };
     }, [detachFromBottom, enabled, scrollToBottomIfFollowing, updateBottomState]);
     const scrollToBottomAfterPaint = useCallback(() => {
+        cancelPendingScrolls();
         const generation = followGenerationRef.current;
         scrollToBottomIfFollowing(generation);
-        requestAnimationFrame(() => {
+        scheduleAnimationFrame(() => {
             scrollToBottomIfFollowing(generation);
-            requestAnimationFrame(() => scrollToBottomIfFollowing(generation));
+            scheduleAnimationFrame(() => scrollToBottomIfFollowing(generation));
         });
-        window.setTimeout(() => scrollToBottomIfFollowing(generation), 80);
-    }, [scrollToBottomIfFollowing]);
+        const timeoutId = window.setTimeout(() => {
+            pendingTimeoutIdsRef.current.delete(timeoutId);
+            scrollToBottomIfFollowing(generation);
+        }, 80);
+        pendingTimeoutIdsRef.current.add(timeoutId);
+    }, [cancelPendingScrolls, scheduleAnimationFrame, scrollToBottomIfFollowing]);
+    useEffect(() => {
+        if (!enabled)
+            cancelPendingScrolls();
+        return cancelPendingScrolls;
+    }, [cancelPendingScrolls, enabled]);
     const resumeFollowing = useCallback(() => {
         const el = scrollRef.current;
         setFollowingBottom(true, true, el ?? undefined);

package/dist/client/embed-auth.js

@@ -11,6 +11,7 @@ const GUARDED_METHODS = new Set(["GET", "HEAD"]);
 const AUTH_FAILURE_HEADER = "x-agent-native-auth-circuit-breaker";
 const MCP_CHAT_BRIDGE_VIEWPORT_STYLE_ID = "agent-native-mcp-chat-bridge-viewport";
 const MCP_CHAT_BRIDGE_VIEWPORT_HEIGHT = 560;
+let pendingMcpChatBridgeViewportNotification = null;
 const authFailureCache = new Map();
 let embedAuthFailure = null;
 function browserWindow() {
@@ -211,11 +212,38 @@ function notifyMcpChatBridgeViewportHeight(win) {
             // Cross-host embeds can deny parent messaging in tests or strict sandboxes.
         }
     };
+    const pending = pendingMcpChatBridgeViewportNotification;
+    pendingMcpChatBridgeViewportNotification = null;
+    if (pending) {
+        if (pending.animationFrameId !== null) {
+            pending.win.cancelAnimationFrame?.(pending.animationFrameId);
+        }
+        for (const id of pending.timeoutIds)
+            pending.win.clearTimeout(id);
+    }
     notify();
+    const nextPending = {
+        win,
+        animationFrameId: null,
+        timeoutIds: [],
+    };
+    pendingMcpChatBridgeViewportNotification = nextPending;
+    const notifyIfCurrent = () => {
+        // Some hosts expose requestAnimationFrame/timers from a different clock
+        // than the one used by clearTimeout. The identity guard keeps a superseded
+        // setup from notifying even when cancellation cannot reach that clock.
+        if (pendingMcpChatBridgeViewportNotification !== nextPending)
+            return;
+        notify();
+    };
     try {
-        win.requestAnimationFrame?.(() => notify());
-        win.setTimeout?.(notify, 250);
-        win.setTimeout?.(notify, 1000);
+        if (win.requestAnimationFrame) {
+            nextPending.animationFrameId = win.requestAnimationFrame(notifyIfCurrent);
+        }
+        if (win.setTimeout) {
+            nextPending.timeoutIds.push(win.setTimeout(notifyIfCurrent, 250));
+            nextPending.timeoutIds.push(win.setTimeout(notifyIfCurrent, 1000));
+        }
     }
     catch {
         // Timers are a progressive enhancement for late host bridge initialization.
@@ -223,6 +251,15 @@ function notifyMcpChatBridgeViewportHeight(win) {
 }
 /** Internal test helper. Do not use in app code. */
 export function _resetEmbedAuthForTests() {
+    if (pendingMcpChatBridgeViewportNotification) {
+        const pending = pendingMcpChatBridgeViewportNotification;
+        pendingMcpChatBridgeViewportNotification = null;
+        if (pending.animationFrameId !== null) {
+            pending.win.cancelAnimationFrame?.(pending.animationFrameId);
+        }
+        for (const id of pending.timeoutIds)
+            pending.win.clearTimeout(id);
+    }
     installed = false;
     memoryToken = null;
     mcpChatBridgeActive = false;

package/dist/client/route-state.js

@@ -37,12 +37,39 @@ function defaultCommandDedupKey(command) {
 function currentRouterPath(location) {
     return `${location.pathname}${location.search}${location.hash}`;
 }
+function shallowEqualNavigationState(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (!left ||
+        !right ||
+        typeof left !== "object" ||
+        typeof right !== "object") {
+        return false;
+    }
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(right, key) ||
+            !Object.is(left[key], right[key])) {
+            return false;
+        }
+    }
+    return true;
+}
 function stringifyForWriteDedup(value) {
     try {
-        return JSON.stringify(value);
+        const serialized = JSON.stringify(value);
+        return typeof serialized === "string"
+            ? serialized
+            : Symbol("unserializable navigation state");
     }
     catch {
-        return "";
+        // Do not turn a serialization failure into a reusable string key. A
+        // distinct token lets a changed unserializable state reach the write path
+        // and surface its real error instead of being silently deduplicated.
+        return Symbol("unserializable navigation state");
     }
 }
 function resolveAgentChatViewTransitionOption(option, command, path) {
@@ -65,10 +92,10 @@ export function useSemanticNavigationState(options) {
     const commandKeys = useMemo(() => uniqueKeys(options.commandKeys ?? ["navigate"]), [options.commandKeys]);
     const commandQueryKey = useMemo(() => options.commandQueryKey ?? ["navigate-command"], [options.commandQueryKey]);
     const navigationState = options.state ?? null;
-    const navigationWriteDedup = stringifyForWriteDedup({
+    const navigationWriteDedup = useMemo(() => stringifyForWriteDedup({
         keys: navigationKeys,
         state: navigationState,
-    });
+    }), [navigationKeys, navigationState]);
     const getCommandDedupKeyRef = useRef(options.getCommandDedupKey);
     const onCommandRef = useRef(options.onCommand);
     const onErrorRef = useRef(options.onError);
@@ -184,7 +211,17 @@ export function useAgentRouteState(options) {
         browserTabId ?? "global",
     ], [browserTabId, commandKey, options.commandQueryKey]);
     const routeLocation = useMemo(() => routeLocationFromReactRouter(location), [location]);
-    const navigationState = options.getNavigationState(routeLocation) ?? null;
+    // Callers may include app-local state in this callback in addition to the
+    // router location. Derive on every render so those values are not frozen at
+    // the last route change, then retain the previous object when its shallow
+    // values are unchanged. This keeps the write-dedup serialization off the
+    // unrelated-render path without hiding captured state updates.
+    const derivedNavigationState = options.getNavigationState(routeLocation) ?? null;
+    const navigationStateRef = useRef(derivedNavigationState);
+    if (!shallowEqualNavigationState(navigationStateRef.current, derivedNavigationState)) {
+        navigationStateRef.current = derivedNavigationState;
+    }
+    const navigationState = navigationStateRef.current;
     return useSemanticNavigationState({
         state: navigationState,
         navigationKeys,

package/dist/client/use-change-version.js

@@ -31,11 +31,13 @@
  * refetch when that source fires. A poll heartbeat with no event does
  * nothing.
  */
-import { useSyncExternalStore } from "react";
+import { useCallback, useMemo, useSyncExternalStore } from "react";
+const MAX_TRACKED_SOURCES = 1_000;
+const ZERO_SNAPSHOT = () => 0;
 class ChangeVersionStore {
     versions = new Map();
-    listeners = new Set();
-    cachedSnapshots = new Map();
+    listeners = new Map();
+    activeSources = new Map();
     /**
      * Advance the counter for `source` to at least `version`. Returns true if
      * the counter actually moved (so callers can avoid spurious work).
@@ -46,31 +48,60 @@ class ChangeVersionStore {
         const current = this.versions.get(source) ?? 0;
         if (version > current) {
             this.versions.set(source, version);
-            this.cachedSnapshots.set(source, version);
-            this.notify();
+            this.evictUnobservedSources();
+            for (const listener of this.listeners.get(source) ?? [])
+                listener();
             return true;
         }
         return false;
     }
     get(source) {
-        // useSyncExternalStore requires reference-stable snapshots for unchanged
-        // values, so we serve from a cached map that we only update inside
-        // `bump`.
-        const cached = this.cachedSnapshots.get(source);
-        if (cached !== undefined)
-            return cached;
-        this.cachedSnapshots.set(source, 0);
-        return 0;
+        return this.versions.get(source) ?? 0;
     }
-    subscribe(listener) {
-        this.listeners.add(listener);
+    subscribe(sources, listener) {
+        const uniqueSources = new Set(sources.filter(Boolean));
+        for (const source of uniqueSources) {
+            this.activeSources.set(source, (this.activeSources.get(source) ?? 0) + 1);
+            let listeners = this.listeners.get(source);
+            if (!listeners) {
+                listeners = new Set();
+                this.listeners.set(source, listeners);
+            }
+            listeners.add(listener);
+        }
         return () => {
-            this.listeners.delete(listener);
+            for (const source of uniqueSources) {
+                const listeners = this.listeners.get(source);
+                listeners?.delete(listener);
+                if (listeners?.size === 0)
+                    this.listeners.delete(source);
+                const count = (this.activeSources.get(source) ?? 1) - 1;
+                if (count > 0)
+                    this.activeSources.set(source, count);
+                else
+                    this.activeSources.delete(source);
+            }
+            this.evictUnobservedSources();
         };
     }
-    notify() {
-        for (const listener of this.listeners)
-            listener();
+    reset() {
+        this.versions.clear();
+        this.listeners.clear();
+        this.activeSources.clear();
+    }
+    evictUnobservedSources() {
+        while (this.versions.size > MAX_TRACKED_SOURCES) {
+            let evicted = false;
+            for (const source of this.versions.keys()) {
+                if (this.activeSources.has(source))
+                    continue;
+                this.versions.delete(source);
+                evicted = true;
+                break;
+            }
+            if (!evicted)
+                return;
+        }
     }
 }
 const store = new ChangeVersionStore();
@@ -110,7 +141,9 @@ export function getChangeVersion(source) {
  * ```
  */
 export function useChangeVersion(source) {
-    return useSyncExternalStore((cb) => store.subscribe(cb), () => store.get(source), () => 0);
+    const subscribe = useCallback((listener) => store.subscribe([source], listener), [source]);
+    const getSnapshot = useCallback(() => store.get(source), [source]);
+    return useSyncExternalStore(subscribe, getSnapshot, ZERO_SNAPSHOT);
 }
 /**
  * Convenience for queries that should refetch on multiple sources — returns
@@ -123,12 +156,25 @@ export function useChangeVersion(source) {
  * ```
  */
 export function useChangeVersions(sources) {
-    return useSyncExternalStore((cb) => store.subscribe(cb), () => sources.reduce((sum, src) => sum + store.get(src), 0), () => 0);
+    const sourceKey = sources
+        .map((source) => `${source.length}:${source}`)
+        .join("\u0001");
+    const stableSources = useMemo(() => {
+        const uniqueSources = [];
+        const seen = new Set();
+        for (const source of sources) {
+            if (seen.has(source))
+                continue;
+            seen.add(source);
+            uniqueSources.push(source);
+        }
+        return uniqueSources;
+    }, [sourceKey]);
+    const subscribe = useCallback((listener) => store.subscribe(stableSources, listener), [stableSources]);
+    const getSnapshot = useCallback(() => stableSources.reduce((sum, src) => sum + store.get(src), 0), [stableSources]);
+    return useSyncExternalStore(subscribe, getSnapshot, ZERO_SNAPSHOT);
 }
 /** Internal test helper — reset all counters. Do not use in app code. */
 export function _resetChangeVersionStoreForTests() {
-    // @ts-expect-error reaching past private to clear state in tests
-    store.versions.clear();
-    // @ts-expect-error reaching past private to clear state in tests
-    store.cachedSnapshots.clear();
+    store.reset();
 }

package/dist/client/use-db-sync.d.ts

@@ -18,6 +18,7 @@ interface QueryClient {
 }
 export type SyncEvent = {
     version?: number;
+    cursorId?: string;
     source?: string;
     type?: string;
     key?: string;