@agent-native/core 0.144.2 → 0.145.0

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/corpus/templates/slides/server/plugins/agent-chat.ts

@@ -43,7 +43,7 @@ export default createAgentChatPlugin({
   // Customer and product activity data belongs to Analytics. Keep raw DB
   // tools out of both the interactive and A2A Slides agent surfaces so the
   // agent cannot bypass the Analytics data dictionary with local SQL.
-  databaseTools: "off",
+  frameworkTools: { database: "off" },
   // Enable sandboxed JavaScript execution so Slides agents can fetch,
   // paginate, and reduce provider data through providerFetch() without us
   // hardcoding one action per Google Drive endpoint.

package/dist/agent/production-agent.d.ts

@@ -196,6 +196,12 @@ export interface ActionEntry {
      * `needsApproval` option. See `packages/core/docs/content/actions.mdx`.
      */
     needsApproval?: boolean | ((args: any, ctx?: import("../action.js").ActionRunContext) => boolean | Promise<boolean>);
+    /** Which framework tool group contributed this action. Set by the framework,
+     *  never by an app: apps own their action names, and a tagged action is one
+     *  the app can switch off wholesale through `frameworkTools`. Tagged actions
+     *  are also excluded from the DEFAULT first-request tool list — they stay
+     *  reachable through `tool-search` unless named in `initialToolNames`. */
+    frameworkGroup?: import("../framework-tools.js").FrameworkToolGroup;
 }
 /** @deprecated Use `ActionEntry` instead */
 export type ScriptEntry = ActionEntry;

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;

package/dist/client/MultiTabAssistantChat.js

@@ -17,6 +17,7 @@ import { callAction } from "./use-action.js";
 import { useChangeVersion } from "./use-change-version.js";
 import { CHAT_MODEL_SELECTION_CHANGED_EVENT } from "./use-chat-models.js";
 import { useChatThreads, } from "./use-chat-threads.js";
+import { usePollLoop } from "./use-poll-loop.js";
 import { cn } from "./utils.js";
 /** The single path that hands a queued send to a mounted chat ref. */
 function deliverPendingSend(ref, send) {
@@ -275,6 +276,7 @@ function chatTabStatusFromAgentTeamStatus(status) {
     return isActiveAgentTeamStatus(status) ? "running" : "completed";
 }
 const STALE_THREAD_THRESHOLD_MS = 12 * 60 * 60 * 1000;
+const DEFAULT_AGENT_TEAM_POLL_MS = 3000;
 const DEFAULT_THREAD_URL_PARAM = "thread";
 const THREAD_URL_CHANGED_EVENT = "agent-chat:url-thread-changed";
 const hasOwn = Object.prototype.hasOwnProperty;
@@ -373,7 +375,7 @@ function runToAgentTeamTabInfo(run) {
         status: run.status ?? "unknown",
     };
 }
-export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderOverlay, contentHidden = false, apiUrl = agentNativePath("/_agent-native/agent-chat"), storageKey, restoreActiveThread = true, browserTabId, threadUrlSync = false, scope = null, ...props }) {
+export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderOverlay, contentHidden = false, apiUrl = agentNativePath("/_agent-native/agent-chat"), storageKey, restoreActiveThread = true, browserTabId, threadUrlSync = false, scope = null, agentTeamPollMs = DEFAULT_AGENT_TEAM_POLL_MS, ...props }) {
     const { enabled: threadUrlSyncEnabled, paramName: threadUrlParamName, routeThreadId, getPath: getThreadPath, navigate: navigateThreadUrl, } = resolveThreadUrlSync(threadUrlSync);
     const threadRouteControlsActiveThread = threadUrlSyncEnabled &&
         threadUrlSync !== true &&
@@ -896,107 +898,92 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
             });
         }
     }, [isLoading, openTabIds, activeThreadId, createThread, writeThreadUrl]);
-    useEffect(() => {
-        let stopped = false;
-        let timer = null;
+    usePollLoop(async (signal) => {
         const runsUrl = `${apiUrl.replace(/\/$/, "")}/runs/list?goalId=agent-team`;
-        async function hydrateAgentTeamTabs() {
-            try {
-                const res = await fetch(runsUrl);
-                if (res.ok) {
-                    const data = (await res.json());
-                    const infos = Array.isArray(data.runs)
-                        ? data.runs
-                            .map(runToAgentTeamTabInfo)
-                            .filter((info) => Boolean(info))
-                        : [];
-                    setSubAgentStatuses((prev) => {
-                        let changed = false;
-                        const next = {};
-                        for (const info of infos) {
-                            next[info.threadId] = info.status;
-                            if (prev[info.threadId] !== info.status)
-                                changed = true;
-                        }
-                        if (Object.keys(prev).length !== Object.keys(next).length) {
+        try {
+            const res = await fetch(runsUrl, { signal });
+            if (res.ok) {
+                const data = (await res.json());
+                const infos = Array.isArray(data.runs)
+                    ? data.runs
+                        .map(runToAgentTeamTabInfo)
+                        .filter((info) => Boolean(info))
+                    : [];
+                setSubAgentStatuses((prev) => {
+                    let changed = false;
+                    const next = {};
+                    for (const info of infos) {
+                        next[info.threadId] = info.status;
+                        if (prev[info.threadId] !== info.status)
                             changed = true;
+                    }
+                    if (Object.keys(prev).length !== Object.keys(next).length) {
+                        changed = true;
+                    }
+                    return changed ? next : prev;
+                });
+                const openSet = new Set(openTabIdsRef.current);
+                const candidates = infos.filter((info) => !dismissedSubAgentTabsRef.current.has(info.threadId) &&
+                    (openSet.has(info.parentThreadId) || openSet.has(info.threadId)));
+                if (candidates.length > 0) {
+                    const shouldRefreshThreads = candidates.some((info) => !openSet.has(info.threadId) && openSet.has(info.parentThreadId));
+                    const candidateParents = new Map(candidates.map((info) => [info.threadId, info.parentThreadId]));
+                    setParentMap((prev) => {
+                        let next = prev;
+                        for (const info of candidates) {
+                            if (next[info.threadId] === info.parentThreadId)
+                                continue;
+                            next =
+                                next === prev
+                                    ? { ...prev, [info.threadId]: info.parentThreadId }
+                                    : { ...next, [info.threadId]: info.parentThreadId };
                         }
-                        return changed ? next : prev;
+                        return next;
                     });
-                    const openSet = new Set(openTabIdsRef.current);
-                    const candidates = infos.filter((info) => !dismissedSubAgentTabsRef.current.has(info.threadId) &&
-                        (openSet.has(info.parentThreadId) || openSet.has(info.threadId)));
-                    if (candidates.length > 0) {
-                        const shouldRefreshThreads = candidates.some((info) => !openSet.has(info.threadId) && openSet.has(info.parentThreadId));
-                        const candidateParents = new Map(candidates.map((info) => [info.threadId, info.parentThreadId]));
-                        setParentMap((prev) => {
-                            let next = prev;
-                            for (const info of candidates) {
-                                if (next[info.threadId] === info.parentThreadId)
-                                    continue;
-                                next =
-                                    next === prev
-                                        ? { ...prev, [info.threadId]: info.parentThreadId }
-                                        : { ...next, [info.threadId]: info.parentThreadId };
-                            }
-                            return next;
-                        });
-                        setSubAgentNames((prev) => {
-                            let next = prev;
-                            for (const info of candidates) {
-                                if (!info.name || next[info.threadId] === info.name)
-                                    continue;
-                                next =
-                                    next === prev
-                                        ? { ...prev, [info.threadId]: info.name }
-                                        : { ...next, [info.threadId]: info.name };
-                            }
-                            return next;
-                        });
-                        setOpenTabIds((prev) => {
-                            let next = prev;
-                            for (const info of candidates) {
-                                if (next.includes(info.threadId))
-                                    continue;
-                                const parentIdx = next.indexOf(info.parentThreadId);
-                                if (parentIdx === -1)
-                                    continue;
-                                if (next === prev)
-                                    next = [...prev];
-                                let insertIdx = parentIdx + 1;
-                                while (insertIdx < next.length) {
-                                    const siblingParent = parentMapRef.current[next[insertIdx]] ||
-                                        candidateParents.get(next[insertIdx]);
-                                    if (siblingParent !== info.parentThreadId)
-                                        break;
-                                    insertIdx++;
-                                }
-                                next.splice(insertIdx, 0, info.threadId);
+                    setSubAgentNames((prev) => {
+                        let next = prev;
+                        for (const info of candidates) {
+                            if (!info.name || next[info.threadId] === info.name)
+                                continue;
+                            next =
+                                next === prev
+                                    ? { ...prev, [info.threadId]: info.name }
+                                    : { ...next, [info.threadId]: info.name };
+                        }
+                        return next;
+                    });
+                    setOpenTabIds((prev) => {
+                        let next = prev;
+                        for (const info of candidates) {
+                            if (next.includes(info.threadId))
+                                continue;
+                            const parentIdx = next.indexOf(info.parentThreadId);
+                            if (parentIdx === -1)
+                                continue;
+                            if (next === prev)
+                                next = [...prev];
+                            let insertIdx = parentIdx + 1;
+                            while (insertIdx < next.length) {
+                                const siblingParent = parentMapRef.current[next[insertIdx]] ||
+                                    candidateParents.get(next[insertIdx]);
+                                if (siblingParent !== info.parentThreadId)
+                                    break;
+                                insertIdx++;
                             }
-                            return next;
-                        });
-                        if (shouldRefreshThreads) {
-                            refreshThreads();
+                            next.splice(insertIdx, 0, info.threadId);
                         }
+                        return next;
+                    });
+                    if (shouldRefreshThreads) {
+                        refreshThreads();
                     }
                 }
             }
-            catch {
-                // Best effort: task cards and manual history still work if this poll fails.
-            }
-            finally {
-                if (!stopped) {
-                    timer = setTimeout(hydrateAgentTeamTabs, 3000);
-                }
-            }
         }
-        hydrateAgentTeamTabs();
-        return () => {
-            stopped = true;
-            if (timer)
-                clearTimeout(timer);
-        };
-    }, [apiUrl, refreshThreads]);
+        catch {
+            // Best effort: task cards and manual history still work if this poll fails.
+        }
+    }, { intervalMs: agentTeamPollMs, pauseWhenHidden: true });
     // Focus the composer when switching tabs
     useEffect(() => {
         if (!activeThreadId)