@agent-native/core 0.144.2 → 0.144.3

package/corpus/templates/mail/app/components/GoogleConnectBanner.tsx

@@ -66,6 +66,16 @@ const STEPS = [
   },
 ];
 
+const DESKTOP_POLL_INTERVAL_MS = 1500;
+const ADD_ACCOUNT_POLL_INTERVAL_MS = 2000;
+// Bounds each poll's fetches so a hung request can't leave its in-flight
+// guard stuck and stall the interval forever.
+const DESKTOP_POLL_ABORT_MS = Math.max(10_000, DESKTOP_POLL_INTERVAL_MS * 4);
+const ADD_ACCOUNT_POLL_ABORT_MS = Math.max(
+  10_000,
+  ADD_ACCOUNT_POLL_INTERVAL_MS * 4,
+);
+
 interface GoogleConnectBannerProps {
   variant?: "banner" | "hero";
 }
@@ -104,6 +114,8 @@ export function GoogleConnectBanner({
   );
   const desktopPollRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const addAccountPollRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const desktopPollInFlightRef = useRef(false);
+  const addAccountPollInFlightRef = useRef(false);
   useEffect(() => {
     return () => {
       if (desktopPollRef.current) clearInterval(desktopPollRef.current);
@@ -130,40 +142,54 @@ export function GoogleConnectBanner({
     const start = Date.now();
     if (desktopPollRef.current) clearInterval(desktopPollRef.current);
     desktopPollRef.current = setInterval(async () => {
+      if (document.hidden || desktopPollInFlightRef.current) return;
+      desktopPollInFlightRef.current = true;
+      const controller = new AbortController();
+      const abortTimer = setTimeout(
+        () => controller.abort(),
+        DESKTOP_POLL_ABORT_MS,
+      );
       try {
-        const res = await fetch(
-          agentNativePath(
-            `/_agent-native/auth/desktop-exchange?flow_id=${flowId}`,
-          ),
-        );
-        const data = await res.json();
-        if (data?.error) {
-          clearInterval(desktopPollRef.current!);
-          desktopPollRef.current = null;
-          setDesktopAuthIssue(data);
-        } else if (data?.token) {
-          clearInterval(desktopPollRef.current!);
-          desktopPollRef.current = null;
-          await fetch(
+        try {
+          const res = await fetch(
             agentNativePath(
-              `/_agent-native/auth/session?_session=${data.token}`,
+              `/_agent-native/auth/desktop-exchange?flow_id=${flowId}`,
             ),
-            {
-              credentials: "include",
-            },
+            { signal: controller.signal },
           );
-          window.location.reload();
-        } else if (Date.now() - start > 120_000) {
-          clearInterval(desktopPollRef.current!);
-          desktopPollRef.current = null;
-        }
-      } catch {
-        if (Date.now() - start > 120_000) {
-          clearInterval(desktopPollRef.current!);
-          desktopPollRef.current = null;
+          const data = await res.json();
+          if (data?.error) {
+            clearInterval(desktopPollRef.current!);
+            desktopPollRef.current = null;
+            setDesktopAuthIssue(data);
+          } else if (data?.token) {
+            clearInterval(desktopPollRef.current!);
+            desktopPollRef.current = null;
+            await fetch(
+              agentNativePath(
+                `/_agent-native/auth/session?_session=${data.token}`,
+              ),
+              {
+                credentials: "include",
+                signal: controller.signal,
+              },
+            );
+            window.location.reload();
+          } else if (Date.now() - start > 120_000) {
+            clearInterval(desktopPollRef.current!);
+            desktopPollRef.current = null;
+          }
+        } catch {
+          if (Date.now() - start > 120_000) {
+            clearInterval(desktopPollRef.current!);
+            desktopPollRef.current = null;
+          }
         }
+      } finally {
+        clearTimeout(abortTimer);
+        desktopPollInFlightRef.current = false;
       }
-    }, 1500);
+    }, DESKTOP_POLL_INTERVAL_MS);
   }
 
   const [authError, setAuthError] = useState<string | null>(null);
@@ -274,20 +300,37 @@ export function GoogleConnectBanner({
     const prevCount = accounts.length;
     if (addAccountPollRef.current) clearInterval(addAccountPollRef.current);
     addAccountPollRef.current = setInterval(async () => {
-      const res = await fetch(
-        agentNativePath("/_agent-native/google/status"),
-      ).catch(() => null);
-      if (res?.ok) {
-        const data = await res.json();
-        if (data.accounts?.length > prevCount) {
-          if (addAccountPollRef.current) {
-            clearInterval(addAccountPollRef.current);
-            addAccountPollRef.current = null;
+      if (document.hidden || addAccountPollInFlightRef.current) return;
+      addAccountPollInFlightRef.current = true;
+      const controller = new AbortController();
+      const abortTimer = setTimeout(
+        () => controller.abort(),
+        ADD_ACCOUNT_POLL_ABORT_MS,
+      );
+      try {
+        const res = await fetch(
+          agentNativePath("/_agent-native/google/status"),
+          { signal: controller.signal },
+        )
+          // coercion-ok: a failed probe and a not-yet-added-account response
+          // both mean "keep waiting"; this loop only acts on an observed
+          // account-count increase.
+          .catch(() => null);
+        if (res?.ok) {
+          const data = await res.json();
+          if (data.accounts?.length > prevCount) {
+            if (addAccountPollRef.current) {
+              clearInterval(addAccountPollRef.current);
+              addAccountPollRef.current = null;
+            }
+            window.location.reload();
           }
-          window.location.reload();
         }
+      } finally {
+        clearTimeout(abortTimer);
+        addAccountPollInFlightRef.current = false;
       }
-    }, 2000);
+    }, ADD_ACCOUNT_POLL_INTERVAL_MS);
     // accounts.length is captured into prevCount above; including it in deps
     // would tear down and recreate the interval whenever the count changes.
     // eslint-disable-next-line react-hooks/exhaustive-deps

package/corpus/templates/mail/app/components/layout/AppLayout.tsx

@@ -96,6 +96,10 @@ type SnoozeTarget = {
 };
 const COMPOSE_FULLSCREEN_PARAM = "composeFullscreen";
 const SIDEBAR_COLLAPSE_KEY = "mail-sidebar-collapsed";
+const ACCOUNT_POLL_INTERVAL_MS = 2000;
+// Bounds the account-status poll so a hung fetch can't leave the in-flight
+// guard stuck and stall the interval forever.
+const ACCOUNT_POLL_ABORT_MS = Math.max(10_000, ACCOUNT_POLL_INTERVAL_MS * 4);
 
 function AccountAvatar({
   email,
@@ -2491,18 +2495,36 @@ function AccountPopover({
     setWantAuthUrl(false);
     window.open(authUrl.data.url, "_blank");
 
+    let inFlight = false;
     const interval = setInterval(async () => {
-      const res = await fetch(
-        agentNativePath("/_agent-native/google/status"),
-      ).catch(() => null);
-      if (res?.ok) {
-        const data = await res.json();
-        if (data.accounts?.length > accounts.length) {
-          clearInterval(interval);
-          window.location.reload();
+      if (document.hidden || inFlight) return;
+      inFlight = true;
+      const controller = new AbortController();
+      const abortTimer = setTimeout(
+        () => controller.abort(),
+        ACCOUNT_POLL_ABORT_MS,
+      );
+      try {
+        const res = await fetch(
+          agentNativePath("/_agent-native/google/status"),
+          { signal: controller.signal },
+        )
+          // coercion-ok: a failed probe and a not-yet-added-account response
+          // both mean "keep waiting"; this loop only acts on an observed
+          // account-count increase.
+          .catch(() => null);
+        if (res?.ok) {
+          const data = await res.json();
+          if (data.accounts?.length > accounts.length) {
+            clearInterval(interval);
+            window.location.reload();
+          }
         }
+      } finally {
+        clearTimeout(abortTimer);
+        inFlight = false;
       }
-    }, 2000);
+    }, ACCOUNT_POLL_INTERVAL_MS);
 
     return () => clearInterval(interval);
   }, [wantAuthUrl, authUrl.data, accounts.length]);

package/corpus/templates/mail/server/plugins/mail-jobs.ts

@@ -1,5 +1,6 @@
 import { registerEvent } from "@agent-native/core/event-bus";
 import { listOAuthAccounts } from "@agent-native/core/oauth-tokens";
+import { startIntervalJob } from "@agent-native/core/server/interval-job";
 import { z } from "zod";
 
 import { processAutomations } from "../lib/automation-engine.js";
@@ -18,6 +19,10 @@ import {
 
 const INTERVAL_MS = 60_000; // 1 minute
 const WATCH_RENEW_INTERVAL_MS = 12 * 60 * 60_000;
+// Backstop for the whole tick (job sends + Gmail watch renewal, both outbound
+// network calls with no timeout of their own), reported through the job's
+// onError so a wedged tick is loud rather than silent.
+const TICK_ABORT_MS = Math.max(10_000, INTERVAL_MS * 4);
 let lastWatchRenewalAt = 0;
 // Vite's dev server initializes Nitro plugins more than once during boot
 // (initial load + post-init). Module-scope flag ensures the "skipping" log
@@ -124,24 +129,38 @@ export default () => {
     return;
   }
 
-  setInterval(async () => {
-    try {
-      await processJobs();
-    } catch (err) {
-      console.error("[mail-jobs] processJobs failed:", err);
-    }
-    try {
-      await processAutomations();
-    } catch (err) {
-      console.error("[mail-jobs] processAutomations failed:", err);
-    }
-    if (Date.now() - lastWatchRenewalAt > WATCH_RENEW_INTERVAL_MS) {
-      lastWatchRenewalAt = Date.now();
+  // The overlap guard and the hung-tick timeout both come from
+  // startIntervalJob rather than a module-level `running` flag here: these
+  // are outbound Google calls with no timeout of their own, and releasing the
+  // guard on the timeout while a hung call kept running is what let a tick
+  // overlap the next one and send duplicate mail.
+  startIntervalJob(
+    async () => {
       try {
-        await renewAllWatches();
+        await processJobs();
       } catch (err) {
-        console.error("[mail-jobs] renewAllWatches failed:", err);
+        console.error("[mail-jobs] processJobs failed:", err);
       }
-    }
-  }, INTERVAL_MS);
+      try {
+        await processAutomations();
+      } catch (err) {
+        console.error("[mail-jobs] processAutomations failed:", err);
+      }
+      if (Date.now() - lastWatchRenewalAt > WATCH_RENEW_INTERVAL_MS) {
+        lastWatchRenewalAt = Date.now();
+        try {
+          await renewAllWatches();
+        } catch (err) {
+          console.error("[mail-jobs] renewAllWatches failed:", err);
+        }
+      }
+    },
+    {
+      intervalMs: INTERVAL_MS,
+      timeoutMs: TICK_ABORT_MS,
+      leading: false,
+      onError: (err) =>
+        console.error("[mail-jobs] tick exceeded time budget:", err),
+    },
+  );
 };

package/dist/client/AssistantChat.js

@@ -7,6 +7,7 @@ import { AssistantRuntimeProvider, useLocalRuntime, useThreadRuntime, useThread,
 import { CompositeAttachmentAdapter } from "@assistant-ui/react";
 import { IconArrowUp, IconClock, IconMessage, IconX, IconPlayerStopFilled, IconTerminal, IconAlertTriangle, IconChevronDown, IconRefresh, } from "@tabler/icons-react";
 import { useState, useRef, useEffect, useCallback, useMemo, useLayoutEffect, forwardRef, useImperativeHandle, } from "react";
+import { createPollEngine } from "../shared/poll-engine.js";
 import { clearPendingTurnIfMatches, clearActiveRunIfMatches, getPendingTurn, getActiveRunActivityTool, getActiveRun, resolveReconnectAfterSeq, setActiveRun, updateActiveRunActivity, updateActiveRunSeq, } from "./active-run-state.js";
 import { activeRunLooksAlive, createAgentChatAdapter, } from "./agent-chat-adapter.js";
 import { appendAgentChatContextToMessage, formatAgentChatContextItemsForPrompt, getAgentChatContextState, isAgentChatSubmitCancelled, normalizeAgentChatContextItem, publishAgentChatContextItems, refreshAgentChatContext, reportAgentChatSubmitResult, subscribeAgentChatContext, } from "./agent-chat.js";
@@ -98,6 +99,13 @@ export function createUserMessageRunConfig(references, requestMode, recoveryActi
     return options;
 }
 const PENDING_SELECTION_KEY = "pending-selection-context";
+// Bounds an in-flight poll fetch so its own boolean in-flight guard is
+// guaranteed to release even if the server never responds. Mirrors
+// use-db-sync.ts's getPollAbortMs.
+const POLL_ABORT_MIN_MS = 10_000;
+function getPollAbortMs(interval) {
+    return Math.max(POLL_ABORT_MIN_MS, interval * 4);
+}
 const ACTIVE_RUN_CLEAR_TIMEOUT_MS = 5_000;
 const ACTIVE_RUN_STUCK_THRESHOLD_MS = 90_000;
 const BACKGROUND_ACTIVE_RUN_STUCK_THRESHOLD_MS = 13 * 60_000;
@@ -1836,7 +1844,11 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
         }
         return repo;
     }, [threadRuntime]);
-    const refreshThreadFromServer = useCallback(async () => {
+    // Accepts an optional external `signal` so poll loops (e.g. the reconnect
+    // thread-poll engine below) can cancel this fetch via their own timeout
+    // instead of racing a second, separately-constructed AbortController.
+    // Callers with no signal of their own keep the internal fallback timeout.
+    const refreshThreadFromServer = useCallback(async (signal) => {
         if (loadHistoryRepository) {
             try {
                 const repo = await loadHistoryRepository();
@@ -1845,13 +1857,21 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
                 return importThreadData(repo);
             }
             catch {
+                // coercion-ok: callers treat null as "keep the thread already
+                // rendered", the same handling an absent repo needs.
                 return null;
             }
         }
         if (!threadId)
             return null;
+        const ownAbort = !signal && typeof AbortController !== "undefined"
+            ? new AbortController()
+            : null;
+        const ownAbortTimer = ownAbort
+            ? setTimeout(() => ownAbort.abort(), getPollAbortMs(2000))
+            : null;
         try {
-            const refreshRes = await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}`);
+            const refreshRes = await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}`, { signal: signal ?? ownAbort?.signal });
             if (!refreshRes.ok)
                 return null;
             const refreshData = await refreshRes.json();
@@ -1860,8 +1880,14 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
             return importThreadData(refreshData.threadData);
         }
         catch {
+            // coercion-ok: an aborted or failed refresh keeps the thread already
+            // rendered; the next poll tick retries.
             return null;
         }
+        finally {
+            if (ownAbortTimer)
+                clearTimeout(ownAbortTimer);
+        }
     }, [apiUrl, importThreadData, loadHistoryRepository, threadId]);
     const exportCleanThreadRepo = useCallback(() => ensureMessageMetadata(normalizeThreadRepository(threadRuntime.export())), [threadRuntime]);
     const exportPersistableThreadRepo = useCallback(() => withLastAssistantRunDuration(exportCleanThreadRepo(), showRunningInUI ? null : lastChatRunDurationMs), [exportCleanThreadRepo, lastChatRunDurationMs, showRunningInUI]);
@@ -2026,37 +2052,38 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
         reconnectAbortRef.current = abortCtrl;
         let reconnectTerminalReason = null;
         const reconnectStuckThresholdMs = activeRunStuckThresholdMs(runInfo);
-        const watchdog = setInterval(async () => {
-            try {
-                const res = await fetch(`${apiUrl}/runs/active?threadId=${encodeURIComponent(threadId)}`);
-                if (!res.ok) {
-                    abortCtrl.abort();
-                    clearInterval(watchdog);
-                    return;
-                }
-                const info = (await res.json());
-                // SINGLE-READER OWNERSHIP: if the adapter runtime came alive while
-                // this reader was attached (user sent a message, adapter adopted the
-                // thread's run), this reader is now the duplicate — kill it. The
-                // false→true runtime-transition effect also unwinds the UI state;
-                // this covers the reader itself.
-                if (isRuntimeRunningRef.current) {
-                    abortCtrl.abort();
-                    clearInterval(watchdog);
-                    return;
-                }
-                if (isReplayableTerminalRun(info)) {
-                    return;
-                }
-                if (info.status !== "running" || activeRunLooksStale(info)) {
-                    abortCtrl.abort();
-                    clearInterval(watchdog);
-                }
+        // This lives inside a useCallback, not component render, so it can't
+        // use the usePollLoop hook (Rules of Hooks) — createPollEngine gives
+        // the same never-overlaps/never-stalls guarantees imperatively.
+        const watchdog = createPollEngine(async (signal) => {
+            if (document.hidden)
+                return;
+            const res = await fetch(`${apiUrl}/runs/active?threadId=${encodeURIComponent(threadId)}`, { signal });
+            if (!res.ok) {
+                abortCtrl.abort();
+                watchdog.stop();
+                return;
             }
-            catch {
-                // Network blip — keep polling.
+            const info = (await res.json());
+            // SINGLE-READER OWNERSHIP: if the adapter runtime came alive while
+            // this reader was attached (user sent a message, adapter adopted the
+            // thread's run), this reader is now the duplicate — kill it. The
+            // false→true runtime-transition effect also unwinds the UI state;
+            // this covers the reader itself.
+            if (isRuntimeRunningRef.current) {
+                abortCtrl.abort();
+                watchdog.stop();
+                return;
             }
-        }, 1000);
+            if (isReplayableTerminalRun(info)) {
+                return;
+            }
+            if (info.status !== "running" || activeRunLooksStale(info)) {
+                abortCtrl.abort();
+                watchdog.stop();
+            }
+        }, { intervalMs: 1000 });
+        watchdog.start();
         let reconnectTimedOut = false;
         // Idle deadline, NOT a total-duration cap. A long-but-healthy run (image
         // generation emits `activity` heartbeats every few seconds) keeps
@@ -2082,7 +2109,7 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
             }
             reconnectTimedOut = true;
             abortCtrl.abort();
-            clearInterval(watchdog);
+            watchdog.stop();
             clearInterval(idleCheck);
         }, 1000);
         const streamReconnect = async () => {
@@ -2119,18 +2146,23 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
                     return "unknown";
                 }
             };
-            const threadPollInterval = afterSeq > 0
-                ? window.setInterval(() => {
+            const threadPollEngine = afterSeq > 0
+                ? createPollEngine(async (signal) => {
+                    if (document.hidden)
+                        return;
                     if (reconnectRunIdRef.current !== runId)
                         return;
-                    // Adapter took over mid-poll — skip imports that would race the
-                    // live stream and flicker tool cards back to older snapshots.
-                    if (isRuntimeRunningRef.current || isAutoResumingRef.current) {
+                    // Adapter took over mid-poll — skip imports that would race
+                    // the live stream and flicker tool cards back to older
+                    // snapshots.
+                    if (isRuntimeRunningRef.current ||
+                        isAutoResumingRef.current) {
                         return;
                     }
-                    void refreshThreadFromServer();
-                }, 2000)
+                    await refreshThreadFromServer(signal);
+                }, { intervalMs: 2000, leading: false })
                 : undefined;
+            threadPollEngine?.start();
             try {
                 const content = [];
                 latestContent = content;
@@ -2213,10 +2245,8 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
                 }
             }
             finally {
-                if (threadPollInterval !== undefined) {
-                    window.clearInterval(threadPollInterval);
-                }
-                clearInterval(watchdog);
+                threadPollEngine?.stop();
+                watchdog.stop();
                 clearInterval(idleCheck);
             }
             // A newer reader, live adapter, stop action, or component unmount took

package/dist/client/MultiTabAssistantChat.d.ts

@@ -66,5 +66,7 @@ export type MultiTabAssistantChatProps = Omit<AssistantChatProps, "tabId" | "thr
     scope?: ChatThreadScope | null;
     /** @deprecated Scope context is now rendered in the composer. */
     showScopeBadge?: boolean;
+    /** Cadence for hydrating agent-team sub-agent tab status. Default: 3000. */
+    agentTeamPollMs?: number;
 };
-export declare function MultiTabAssistantChat({ showTabBar, renderHeader, renderOverlay, contentHidden, apiUrl, storageKey, restoreActiveThread, browserTabId, threadUrlSync, scope, ...props }: MultiTabAssistantChatProps): React.JSX.Element;
+export declare function MultiTabAssistantChat({ showTabBar, renderHeader, renderOverlay, contentHidden, apiUrl, storageKey, restoreActiveThread, browserTabId, threadUrlSync, scope, agentTeamPollMs, ...props }: MultiTabAssistantChatProps): React.JSX.Element;