@agent-native/core 0.144.1 → 0.144.3

package/dist/client/use-run-stuck-detection.js

@@ -1,4 +1,5 @@
 import { useEffect, useState, useCallback } from "react";
+import { createPollEngine } from "../shared/poll-engine.js";
 import { agentNativePath } from "./api-path.js";
 const DEFAULT_STUCK_THRESHOLD_MS = 90_000;
 export const DEFAULT_BACKGROUND_STUCK_THRESHOLD_MS = 180_000;
@@ -7,6 +8,12 @@ const DEFAULT_POLL_INTERVAL_MS = 5_000;
 const IDLE_BACKOFF_INTERVAL_MS = 15_000;
 const MAX_POLL_ERROR_BACKOFF_MS = 30_000;
 const FRESH_BACKGROUND_HEARTBEAT_MS = 30_000;
+// Bounds each poll fetch so a hung request can't stall the self-rescheduling
+// setTimeout loop forever (the reschedule only fires once the fetch settles).
+const POLL_ABORT_MIN_MS = 10_000;
+function getPollAbortMs(interval) {
+    return Math.max(POLL_ABORT_MIN_MS, interval * 4);
+}
 const EMPTY_STATE = {
     isStuck: false,
     runId: null,
@@ -28,10 +35,15 @@ export function useRunStuckDetection({ threadId, enabled = true, stuckThresholdM
             return;
         const base = apiUrl ?? agentNativePath("/_agent-native/agent-chat");
         let cancelled = false;
-        let timer = null;
         let snapshotTransitionTimer = null;
         let snapshotVersion = 0;
         let consecutivePollFailures = 0;
+        // The engine's own cadence varies per tick (idle backoff, error backoff),
+        // which is why intervalMs below reads from this ref instead of a fixed
+        // number. Stagger the very first poll so a freshly-started run isn't
+        // immediately classified as stuck before the server has had a chance to
+        // record any progress events.
+        const nextDelayRef = { current: 2_000 };
         const pollFailureDelay = () => {
             consecutivePollFailures += 1;
             return Math.min(Math.max(pollIntervalMs, 1) * 2 ** consecutivePollFailures, MAX_POLL_ERROR_BACKOFF_MS);
@@ -124,12 +136,10 @@ export function useRunStuckDetection({ threadId, enabled = true, stuckThresholdM
                 scheduleSnapshotTransition(snapshot, observedAtMs, version);
             }, delayMs);
         };
-        const poll = async () => {
-            if (cancelled)
-                return;
+        const attempt = async (signal) => {
             let nextDelay = pollIntervalMs;
             try {
-                const res = await fetch(`${base}/runs/active?threadId=${encodeURIComponent(threadId)}`, { credentials: "same-origin" });
+                const res = await fetch(`${base}/runs/active?threadId=${encodeURIComponent(threadId)}`, { credentials: "same-origin", signal });
                 if (cancelled)
                     return;
                 if (res.ok) {
@@ -203,21 +213,39 @@ export function useRunStuckDetection({ threadId, enabled = true, stuckThresholdM
                 // while the server or database recovers.
                 nextDelay = pollFailureDelay();
             }
-            if (!cancelled) {
-                timer = setTimeout(poll, nextDelay);
+            finally {
+                nextDelayRef.current = nextDelay;
+            }
+        };
+        // The per-tick backoff above needs a variable cadence, which is why this
+        // uses createPollEngine directly instead of usePollLoop (whose public
+        // intervalMs is a fixed number) — see poll-engine.ts for the
+        // never-overlaps/never-stalls guarantees this still gets for free.
+        const engine = createPollEngine(attempt, {
+            intervalMs: () => nextDelayRef.current,
+            timeoutMs: getPollAbortMs(pollIntervalMs),
+            leading: false,
+        });
+        engine.start();
+        const onVisibilityChange = () => {
+            if (document.hidden) {
+                engine.stop();
+            }
+            else {
+                // Resume immediately rather than waiting out whatever delay was
+                // pending before the tab was hidden (which may be a long backoff).
+                engine.start();
+                engine.pollNow();
             }
         };
-        // Stagger the first poll so a freshly-started run isn't immediately
-        // classified as stuck before the server has had a chance to record
-        // any progress events.
-        timer = setTimeout(poll, 2_000);
+        document.addEventListener("visibilitychange", onVisibilityChange);
         return () => {
             cancelled = true;
             snapshotVersion += 1;
-            if (timer)
-                clearTimeout(timer);
+            engine.stop();
             if (snapshotTransitionTimer)
                 clearTimeout(snapshotTransitionTimer);
+            document.removeEventListener("visibilitychange", onVisibilityChange);
         };
     }, [
         threadId,

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

@@ -17,11 +17,11 @@ declare const _default: import("../../action.js").ActionDefinition<{
     id?: undefined;
     provider?: undefined;
 } | {
-    error?: undefined;
     configured?: undefined;
     connectPath?: undefined;
     url: string;
     id: string;
     provider: string;
+    error?: undefined;
 }>;
 export default _default;

package/dist/integrations/google-docs-poller.js

@@ -7,6 +7,7 @@ import { buildAssistantMessage, extractThreadMeta, } from "../agent/thread-data-
 import { attachToolSearch } from "../agent/tool-search.js";
 import { createThread, getThread, setThreadSourceIfMissing, updateThreadData, } from "../chat-threads/store.js";
 import { resolveOrgIdForEmail } from "../org/context.js";
+import { startIntervalJob, } from "../server/interval-job.js";
 import { runWithRequestContext } from "../server/request-context.js";
 import { getServiceAccountAccessToken, getServiceAccountEmail, getStartPageToken, googleDocsAdapter, listChanges, listDocComments, } from "./adapters/google-docs.js";
 import { getIntegrationConfig, integrationConfigWriteEpoch, saveIntegrationConfig, } from "./config-store.js";
@@ -17,7 +18,13 @@ const DEFAULT_TRIGGER = "@agent";
 const processedComments = new Set();
 /** Track last-checked time per document for comment filtering */
 const lastCheckedTimes = new Map();
-let pollerInterval = null;
+let pollerJob = null;
+// Held only for the startup delay below. It counts as "already running" for
+// both the idempotency guard and stop(): `pollerJob` is still null during that
+// window, so without this a second start() would build a second independent
+// poller, and a stop() inside the window could not prevent the loop from
+// arming itself afterwards.
+let pollerStartTimer = null;
 let activeOptions = null;
 // ─── Watch Channel Management ───────────────────────────────────────────────
 /** How long a watch channel lasts (Google max is ~24h, we use 23h to renew early) */
@@ -429,7 +436,7 @@ async function persistThreadData(threadId, userText, completedRun, thread) {
  *    in case a push notification is missed
  */
 export async function startGoogleDocsPoller(options) {
-    if (pollerInterval) {
+    if (pollerJob || pollerStartTimer) {
         console.warn("[google-docs] Already running");
         return;
     }
@@ -490,8 +497,16 @@ function startPollLoop(options, intervalMs) {
             console.error("[google-docs] Poller error:", detail);
         }
     }
-    setTimeout(poll, 5000);
-    pollerInterval = setInterval(poll, intervalMs);
+    // processChanges ultimately calls the Drive/Docs REST API
+    // (adapters/google-docs.ts), none of whose fetch()s carry a request
+    // timeout — startIntervalJob's own cadence-scaled timeout backstops a hung
+    // call, same convention as SyncTransport's poll abort.
+    if (pollerStartTimer)
+        clearTimeout(pollerStartTimer);
+    pollerStartTimer = setTimeout(() => {
+        pollerStartTimer = null;
+        pollerJob = startIntervalJob(poll, { intervalMs });
+    }, 5000);
     const email = getServiceAccountEmail();
     if (process.env.DEBUG) {
         console.log(`[google-docs] Poll loop started (interval: ${intervalMs / 1000}s, service account: ${email ?? "not configured"})`);
@@ -501,9 +516,13 @@ function startPollLoop(options, intervalMs) {
  * Stop the Google Docs integration.
  */
 export async function stopGoogleDocsPoller() {
-    if (pollerInterval) {
-        clearInterval(pollerInterval);
-        pollerInterval = null;
+    if (pollerStartTimer) {
+        clearTimeout(pollerStartTimer);
+        pollerStartTimer = null;
+    }
+    if (pollerJob) {
+        pollerJob.stop();
+        pollerJob = null;
     }
     if (watchRenewalTimer) {
         clearTimeout(watchRenewalTimer);

package/dist/integrations/pending-tasks-retry-job.js

@@ -1,4 +1,5 @@
 import { getDbExec } from "../db/client.js";
+import { startIntervalJob, } from "../server/interval-job.js";
 import { hasActiveIntegrationCampaign } from "./integration-campaigns-store.js";
 import { configuredIntegrationDurableDispatchScopes, dispatchPendingIntegrationTask, isIntegrationDurableDispatchEnabledForTask, } from "./integration-durable-dispatch.js";
 import { ensurePendingTasksTable, MAX_PENDING_TASK_ATTEMPTS, } from "./pending-tasks-store.js";
@@ -39,8 +40,8 @@ const SERVERLESS_PROCESSING_STUCK_AFTER_MS = 75_000;
 const DURABLE_BACKGROUND_PROCESSING_STUCK_AFTER_MS = 16 * 60 * 1000;
 /** After this many attempts we give up and mark the task failed */
 const DEFAULT_SWEEP_LIMIT = 100;
-let retryInterval = null;
-let initialTimer = null;
+let job = null;
+let startupTimer = null;
 let activeWebhookBaseUrl;
 /**
  * Whether the table exists. Cached after first probe so we don't log every
@@ -268,38 +269,31 @@ function getProcessingStuckAfterMs() {
  * is a no-op.
  */
 export function startPendingTasksRetryJob(options) {
-    if (retryInterval)
+    if (job || startupTimer)
         return;
     activeWebhookBaseUrl = options?.webhookBaseUrl;
     // Stagger the first run a bit so we don't hammer the DB immediately on boot.
-    initialTimer = setTimeout(() => {
-        void retryStuckPendingTasks().catch((err) => {
-            console.error("[integrations] Pending-tasks retry job error:", err);
+    startupTimer = setTimeout(() => {
+        startupTimer = null;
+        job = startIntervalJob(async () => void (await retryStuckPendingTasks()), {
+            intervalMs: RETRY_INTERVAL_MS,
+            onError: (err) => {
+                console.error("[integrations] Pending-tasks retry job error:", err);
+            },
         });
     }, 10_000);
-    unrefTimer(initialTimer);
-    retryInterval = setInterval(() => {
-        void retryStuckPendingTasks().catch((err) => {
-            console.error("[integrations] Pending-tasks retry job error:", err);
-        });
-    }, RETRY_INTERVAL_MS);
-    unrefTimer(retryInterval);
+    startupTimer.unref?.();
     if (process.env.DEBUG) {
         console.log(`[integrations] Pending-tasks retry job started (every ${RETRY_INTERVAL_MS / 1000}s)`);
     }
 }
 /** Stop the retry loop. */
 export function stopPendingTasksRetryJob() {
-    if (initialTimer) {
-        clearTimeout(initialTimer);
-        initialTimer = null;
-    }
-    if (retryInterval) {
-        clearInterval(retryInterval);
-        retryInterval = null;
+    if (startupTimer) {
+        clearTimeout(startupTimer);
+        startupTimer = null;
     }
+    job?.stop();
+    job = null;
     activeWebhookBaseUrl = undefined;
 }
-function unrefTimer(timer) {
-    timer.unref?.();
-}

package/dist/integrations/plugin.js

@@ -13,6 +13,7 @@ import { resolveSecret } from "../server/credential-provider.js";
 import { getH3App, markDefaultPluginProvided, } from "../server/framework-request-handler.js";
 import { decodeOAuthState, encodeOAuthState, oauthCallbackResponse, oauthErrorPage, resolveOAuthRedirectUri, } from "../server/google-oauth.js";
 import { readBody } from "../server/h3-helpers.js";
+import { startIntervalJob, } from "../server/interval-job.js";
 import { runWithRequestContext } from "../server/request-context.js";
 import { processA2AContinuationById, processDueA2AContinuations, reconcileTerminalA2AParentIfDisabled, recoverA2AContinuationAfterProcessorFailure, recoverDueA2AContinuations, } from "./a2a-continuation-processor.js";
 import { getA2AContinuationTaskOutcome } from "./a2a-continuations-store.js";
@@ -50,7 +51,12 @@ import { assertSlackInstallAccess, buildSlackAuthorizeUrl, exchangeSlackOAuthCod
 import { getTaskQueueStats } from "./task-queue-stats.js";
 import { listIntegrationUsageBudgets, saveIntegrationUsageBudget, } from "./usage-budget-store.js";
 import { handleWebhook, processIntegrationTask, recordIntegrationResponseDelivery, } from "./webhook-handler.js";
-let a2aContinuationRetryInterval = null;
+// Timer-driven sweep only — the atomic DB claim inside
+// processDueA2AContinuations already makes concurrent calls (this timer, the
+// opportunistic post-dispatch sweep, etc.) safe.
+let a2aContinuationJob = null;
+let a2aContinuationStartupTimer = null;
+const A2A_CONTINUATION_SWEEP_INTERVAL_MS = 60_000;
 const INTEGRATION_DELIVERY_LEASE_MS = 2 * 60_000;
 async function checkpointIntegrationDeliveryRetry(task, payload, errorMessage, event, campaignLease) {
     let terminalStatus;
@@ -156,23 +162,18 @@ async function containFailedDeliveryTransition(task, errorMessage, event) {
     });
 }
 function startA2AContinuationRetryJob(adapters) {
-    if (a2aContinuationRetryInterval)
+    if (a2aContinuationJob || a2aContinuationStartupTimer)
         return;
-    const initialTimer = setTimeout(() => {
-        processDueA2AContinuations({ adapters }).catch((err) => {
-            console.error("[integrations] A2A continuation retry job failed:", err);
+    a2aContinuationStartupTimer = setTimeout(() => {
+        a2aContinuationStartupTimer = null;
+        a2aContinuationJob = startIntervalJob(() => processDueA2AContinuations({ adapters }), {
+            intervalMs: A2A_CONTINUATION_SWEEP_INTERVAL_MS,
+            onError: (err) => {
+                console.error("[integrations] A2A continuation retry job failed:", err);
+            },
         });
     }, 10_000);
-    unrefTimer(initialTimer);
-    a2aContinuationRetryInterval = setInterval(() => {
-        processDueA2AContinuations({ adapters }).catch((err) => {
-            console.error("[integrations] A2A continuation retry job failed:", err);
-        });
-    }, 60_000);
-    unrefTimer(a2aContinuationRetryInterval);
-}
-function unrefTimer(timer) {
-    timer.unref?.();
+    a2aContinuationStartupTimer.unref?.();
 }
 // ─── Google Pub/Sub OIDC verifier (for Drive changes.watch push) ────────────
 // Cache Google's public keys for OIDC verification. jose handles TTL +

package/dist/integrations/remote-push-delivery-job.js

@@ -1,12 +1,9 @@
+import { startIntervalJob, } from "../server/interval-job.js";
 import { deliverPendingRemotePushNotifications } from "./remote-push-delivery.js";
 const DELIVERY_INTERVAL_MS = 60_000;
-let retryInterval = null;
-let initialTimer = null;
-let running = false;
+let job = null;
+let startupTimer = null;
 export async function runRemotePushDelivery() {
-    if (running)
-        return;
-    running = true;
     try {
         await deliverPendingRemotePushNotifications();
     }
@@ -15,29 +12,23 @@ export async function runRemotePushDelivery() {
             error: error instanceof Error ? error.name : "UnknownError",
         });
     }
-    finally {
-        running = false;
-    }
 }
 export function startRemotePushDeliveryJob() {
-    if (retryInterval)
+    if (job || startupTimer)
         return;
-    initialTimer = setTimeout(() => void runRemotePushDelivery(), 10_000);
-    unrefTimer(initialTimer);
-    retryInterval = setInterval(() => void runRemotePushDelivery(), DELIVERY_INTERVAL_MS);
-    unrefTimer(retryInterval);
+    startupTimer = setTimeout(() => {
+        startupTimer = null;
+        job = startIntervalJob(runRemotePushDelivery, {
+            intervalMs: DELIVERY_INTERVAL_MS,
+        });
+    }, 10_000);
+    startupTimer.unref?.();
 }
 export function stopRemotePushDeliveryJob() {
-    if (initialTimer) {
-        clearTimeout(initialTimer);
-        initialTimer = null;
+    if (startupTimer) {
+        clearTimeout(startupTimer);
+        startupTimer = null;
     }
-    if (retryInterval) {
-        clearInterval(retryInterval);
-        retryInterval = null;
-    }
-    running = false;
-}
-function unrefTimer(timer) {
-    timer.unref?.();
+    job?.stop();
+    job = null;
 }

package/dist/integrations/remote-retry-job.js

@@ -1,7 +1,8 @@
+import { startIntervalJob, } from "../server/interval-job.js";
 import { retryStaleRemoteCommands } from "./remote-commands-store.js";
 const RETRY_INTERVAL_MS = 60_000;
-let retryInterval = null;
-let initialTimer = null;
+let job = null;
+let startupTimer = null;
 export async function retryRemoteCommands() {
     try {
         return await retryStaleRemoteCommands();
@@ -14,31 +15,26 @@ export async function retryRemoteCommands() {
     }
 }
 export function startRemoteCommandsRetryJob() {
-    if (retryInterval)
+    if (job || startupTimer)
         return;
-    initialTimer = setTimeout(() => {
-        void retryRemoteCommands().catch((err) => {
-            console.error("[integrations] Remote command retry job error:", err);
+    startupTimer = setTimeout(() => {
+        startupTimer = null;
+        job = startIntervalJob(async () => {
+            await retryRemoteCommands();
+        }, {
+            intervalMs: RETRY_INTERVAL_MS,
+            onError: (err) => {
+                console.error("[integrations] Remote command retry job error:", err);
+            },
         });
     }, 10_000);
-    unrefTimer(initialTimer);
-    retryInterval = setInterval(() => {
-        void retryRemoteCommands().catch((err) => {
-            console.error("[integrations] Remote command retry job error:", err);
-        });
-    }, RETRY_INTERVAL_MS);
-    unrefTimer(retryInterval);
+    startupTimer.unref?.();
 }
 export function stopRemoteCommandsRetryJob() {
-    if (initialTimer) {
-        clearTimeout(initialTimer);
-        initialTimer = null;
-    }
-    if (retryInterval) {
-        clearInterval(retryInterval);
-        retryInterval = null;
+    if (startupTimer) {
+        clearTimeout(startupTimer);
+        startupTimer = null;
     }
-}
-function unrefTimer(timer) {
-    timer.unref?.();
+    job?.stop();
+    job = null;
 }

package/dist/mcp/screen-memory-stdio.d.ts

@@ -137,13 +137,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -159,7 +159,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
-            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -175,6 +174,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -190,7 +190,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
-            count?: undefined;
             minutes: {
                 type: string;
                 description: string;
@@ -200,6 +199,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -216,7 +216,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -235,6 +234,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             };
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -250,7 +250,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
@@ -264,6 +263,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 description: string;
             };
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             includeMicrophone?: undefined;
@@ -314,13 +314,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt: {
                 type: string;
                 description: string;
@@ -349,13 +349,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;

package/dist/notifications/routes.d.ts

@@ -16,18 +16,18 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
     error?: undefined;
     ok?: undefined;
 } | {
-    count?: undefined;
     updated: number;
     error?: undefined;
     ok?: undefined;
-} | {
     count?: undefined;
+} | {
     updated?: undefined;
     error: string;
     ok?: undefined;
-} | {
     count?: undefined;
+} | {
     updated?: undefined;
     ok: boolean;
     error?: undefined;
+    count?: undefined;
 }>>;

package/dist/oauth-tokens/google-refresh.js

@@ -11,8 +11,11 @@
  * server plugin (see `templates/mail/server/plugins/oauth-refresh.ts`).
  */
 import { resolveGoogleProviderCredentialCandidates } from "../server/google-oauth-credentials.js";
+import { startIntervalJob } from "../server/interval-job.js";
 import { listOAuthAccounts, saveOAuthTokens } from "./store.js";
 const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+/** Bounds each per-account refresh call — this loop runs sequentially over every expiring account. */
+const REFRESH_REQUEST_TIMEOUT_MS = 15_000;
 async function refreshOne(refreshToken) {
     const credentialCandidates = resolveGoogleProviderCredentialCandidates();
     if (!credentialCandidates.length) {
@@ -30,6 +33,7 @@ async function refreshOne(refreshToken) {
                 client_secret: credentials.clientSecret,
                 grant_type: "refresh_token",
             }),
+            signal: AbortSignal.timeout(REFRESH_REQUEST_TIMEOUT_MS),
         });
         lastStatusText = res.statusText;
         data = (await res.json());
@@ -91,7 +95,6 @@ export async function refreshExpiringGoogleTokens(opts = {}) {
     }
 }
 let _started = false;
-let _timer;
 /**
  * Start the refresh loop. Idempotent — calling more than once is a no-op,
  * so multiple plugins/templates loading this in the same process are safe.
@@ -108,25 +111,15 @@ export function startGoogleTokenRefreshLoop(opts = {}) {
     }
     const intervalMs = opts.intervalMs ?? 20 * 60 * 1000;
     const bufferMs = opts.bufferMs ?? 15 * 60 * 1000;
-    // Kick off an initial pass shortly after startup (not immediately — the DB
+    // Kick off the first pass shortly after startup (not immediately — the DB
     // may still be initializing).
-    const initialTimer = setTimeout(() => {
-        refreshExpiringGoogleTokens({ bufferMs }).catch((err) => {
-            console.error("[google-refresh] initial pass failed:", err);
+    const startupTimer = setTimeout(() => {
+        startIntervalJob(() => refreshExpiringGoogleTokens({ bufferMs }), {
+            intervalMs,
+            onError: (err) => {
+                console.error("[google-refresh] refresh pass failed:", err);
+            },
         });
     }, 30_000);
-    _timer = setInterval(() => {
-        refreshExpiringGoogleTokens({ bufferMs }).catch((err) => {
-            console.error("[google-refresh] interval pass failed:", err);
-        });
-    }, intervalMs);
-    // Don't let either timer keep the process alive on its own.
-    if (typeof initialTimer === "object" &&
-        initialTimer &&
-        "unref" in initialTimer) {
-        initialTimer.unref();
-    }
-    if (typeof _timer === "object" && _timer && "unref" in _timer) {
-        _timer.unref();
-    }
+    startupTimer.unref?.();
 }

package/dist/observability/routes.d.ts

@@ -42,22 +42,22 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     avgEvalScore: number;
 } | {
     error?: undefined;
-    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
-    ok?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
-} | {
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
+    ok?: undefined;
 } | {
     error?: undefined;
     summary?: undefined;

package/dist/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;