@agent-native/core 0.161.10 → 0.161.12

package/dist/action.js

@@ -326,8 +326,8 @@ const SUBSCHEMA_MAP_KEYS = [
     "dependentSchemas",
 ];
 /**
- * Remove JSON Schema keywords that some providers' function-calling schema
- * validators reject. OpenAI (and Gemini via the Builder gateway) reject
+ * Remove or rewrite JSON Schema keywords that some providers' function-calling
+ * schema validators reject. OpenAI (and Gemini via the Builder gateway) reject
  * `propertyNames` — which Zod v4 emits for `z.record(z.string(), …)` — with a
  * `400 invalid_function_parameters` error, causing the model turn to produce no
  * content (surfacing as an empty assistant response). Anthropic ignores the
@@ -335,6 +335,15 @@ const SUBSCHEMA_MAP_KEYS = [
  * portable. `propertyNames` only constrained object *keys*; the value/shape of
  * the object is unaffected by its removal.
  *
+ * OpenAI rejects `oneOf` the same way — "Invalid schema for function 'x': …
+ * 'oneOf' is not permitted" — while accepting `anyOf`. Zod v4's `toJSONSchema`
+ * emits `oneOf` for every `z.discriminatedUnion`, so any action with one was
+ * 400'd for the whole request before a token streamed, and the gateway folded
+ * that 400 into a generic 500. Measured: 178k events / 786 users over seven
+ * weeks from a single action. For a discriminated union the two keywords accept
+ * the same documents, and the tool-input validator already handles both
+ * (see `narrowUnionBranchErrors`), so the rewrite is behaviour-preserving.
+ *
  * Only descends through actual subschema positions (properties, items, union
  * branches, definitions, etc.) — never through value-bearing keywords like
  * `default`, `const`, `enum`, or `examples`, whose objects may legitimately
@@ -371,6 +380,14 @@ function stripUnsupportedSchemaKeywords(node) {
             }
         }
     }
+    // After descending, so nested unions are rewritten too. Merged rather than
+    // overwritten on the pathological case where a schema carries both: dropping
+    // either arm would silently narrow what the tool accepts.
+    if (Array.isArray(obj.oneOf)) {
+        const existing = Array.isArray(obj.anyOf) ? obj.anyOf : [];
+        obj.anyOf = [...existing, ...obj.oneOf];
+        delete obj.oneOf;
+    }
     return node;
 }
 /**

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

@@ -84,7 +84,16 @@ export async function checkChatHealthAndAlert(now = Date.now()) {
     if (badRate < BAD_RATE_THRESHOLD) {
         return { status: "healthy", turns: counts.turns, badRate };
     }
-    const stored = await getSetting(LAST_ALERT_SETTING_KEY).catch(() => null);
+    // 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 {

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;