@chrysb/alphaclaw 0.9.9 → 0.9.11

package/lib/public/js/components/agents-tab/agent-overview/use-model-card.js

@@ -2,6 +2,7 @@ import { useEffect, useMemo, useState } from "preact/hooks";
 import { useModels } from "../../models-tab/use-models.js";
 import {
   buildProviderHasAuth,
+  buildSyntheticModelEntry,
   getModelCatalogProvider,
   getModelsTabAuthProvider,
   getProviderSortIndex,
@@ -51,10 +52,8 @@ export const useModelCard = ({
       Object.keys(configuredModels || {})
         .map(
           (modelKey) =>
-            resolveCatalogModel(catalog, modelKey) || {
-              key: modelKey,
-              label: modelKey,
-            },
+            resolveCatalogModel(catalog, modelKey) ||
+            buildSyntheticModelEntry(modelKey),
         )
         .filter((model) => {
           const provider = getModelsTabAuthProvider(model.key);
@@ -75,7 +74,7 @@ export const useModelCard = ({
   const effectiveModelEntry = useMemo(
     () =>
       resolveCatalogModel(catalog, effectiveModel) ||
-      (effectiveModel ? { key: effectiveModel, label: effectiveModel } : null),
+      (effectiveModel ? buildSyntheticModelEntry(effectiveModel) : null),
     [catalog, effectiveModel],
   );
 

package/lib/public/js/components/agents-tab/agent-pairing-section.js

@@ -241,12 +241,14 @@ export const AgentPairingSection = ({ agent = {} }) => {
     },
     3000,
     {
-      enabled: hasUnpaired && ownedAccounts.length > 0,
+      enabled: ownedAccounts.length > 0,
       cacheKey: `/api/pairings?agent=${encodeURIComponent(agentId)}`,
+      dedupeInFlight: true,
     },
   );
 
   const pending = pairingsPoll.data || [];
+  const showPairings = hasUnpaired || pending.length > 0 || pairingStatusRefreshing;
 
   const refreshAfterPairingAction = useCallback(() => {
     setPairingStatusRefreshing(true);
@@ -262,7 +264,7 @@ export const AgentPairingSection = ({ agent = {} }) => {
     }
     pairingDelayedRefreshTimerRefs.current = [];
     const refresh = () => {
-      pairingsPoll.refresh();
+      pairingsPoll.refresh({ force: true });
       loadBindings();
       announcePairingsChanged(agentId);
     };
@@ -273,10 +275,12 @@ export const AgentPairingSection = ({ agent = {} }) => {
 
   const handleApprove = async (id, channel, accountId = "") => {
     try {
-      await approvePairing(id, channel, accountId);
+      const result = await approvePairing(id, channel, accountId);
+      if (!result.ok) throw new Error(result.error || "Could not approve pairing");
       refreshAfterPairingAction();
     } catch (err) {
       showToast(err.message || "Could not approve pairing", "error");
+      throw err;
     }
   };
 
@@ -286,6 +290,7 @@ export const AgentPairingSection = ({ agent = {} }) => {
       refreshAfterPairingAction();
     } catch (err) {
       showToast(err.message || "Could not reject pairing", "error");
+      throw err;
     }
   };
 
@@ -298,13 +303,14 @@ export const AgentPairingSection = ({ agent = {} }) => {
     `;
   }
 
-  if (!hasUnpaired) return null;
+  if (!showPairings) return null;
 
   return html`
     <${Pairings}
       pending=${pending}
       channels=${ownedChannelsStatus}
-      visible=${hasUnpaired}
+      visible=${showPairings}
+      pollingInFlight=${pairingsPoll.isPolling}
       statusRefreshing=${pairingStatusRefreshing}
       onApprove=${handleApprove}
       onReject=${handleReject}

package/lib/public/js/components/cron-tab/cron-helpers.js

@@ -7,6 +7,18 @@ import {
 
 export const kAllCronJobsRouteKey = "__all__";
 
+export const readCronJobPrompt = (job = {}) => {
+  const payload = job?.payload && typeof job.payload === "object" ? job.payload : {};
+  const kind = String(payload?.kind || "").trim();
+  if (kind === "systemEvent" && typeof payload.text === "string") {
+    return payload.text;
+  }
+  if (kind === "agentTurn" && typeof payload.message === "string") {
+    return payload.message;
+  }
+  return "";
+};
+
 const kWeekdayLabelByCronValue = {
   "0": "Sun",
   "1": "Mon",
@@ -388,7 +400,7 @@ export const buildCronOptimizationWarnings = (jobs = [], bulkRunsByJobId = {}) =
   const warnings = [];
   jobs.forEach((job) => {
     const jobId = String(job?.id || "");
-    const prompt = String(job?.payload?.message || "").toLowerCase();
+    const prompt = readCronJobPrompt(job).toLowerCase();
     const deliveryMode = String(job?.delivery?.mode || "").toLowerCase();
     if (
       deliveryMode === "none" &&

package/lib/public/js/components/cron-tab/use-cron-tab.js

@@ -22,7 +22,7 @@ import {
 } from "../../lib/api.js";
 import { readUiSettings, writeUiSettings } from "../../lib/ui-settings.js";
 import { showToast } from "../toast.js";
-import { kAllCronJobsRouteKey } from "./cron-helpers.js";
+import { kAllCronJobsRouteKey, readCronJobPrompt } from "./cron-helpers.js";
 
 const kDefaultListPanelWidthPx = 372;
 const kListPanelMinWidthPx = 220;
@@ -178,6 +178,7 @@ export const useCronTab = ({ jobId = "", onSetLocation = () => {} } = {}) => {
     () => jobs.find((job) => String(job?.id || "") === selectedJobId) || null,
     [jobs, selectedJobId],
   );
+  const selectedJobPrompt = readCronJobPrompt(selectedJob);
 
   useEffect(() => {
     if (!selectedJobId) {
@@ -186,11 +187,11 @@ export const useCronTab = ({ jobId = "", onSetLocation = () => {} } = {}) => {
       setRoutingDraft(kRoutingDefaults);
       return;
     }
-    const prompt = String(selectedJob?.payload?.message || "");
+    const prompt = selectedJobPrompt;
     setPromptValue(prompt);
     setSavedPromptValue(prompt);
     setRoutingDraft(readRoutingDraftFromJob(selectedJob));
-  }, [selectedJobId, selectedJob?.payload?.message]);
+  }, [selectedJobId, selectedJobPrompt]);
 
   useEffect(() => {
     if (!selectedJobId) return;

package/lib/public/js/components/general/index.js

@@ -62,6 +62,10 @@ export const GeneralTab = ({
     Array.isArray(state.pending) &&
     state.pending.length === 0 &&
     hasWhatsAppAwaitingPairing;
+  const showPairings =
+    state.hasUnpaired ||
+    (Array.isArray(state.pending) && state.pending.length > 0) ||
+    state.pairingStatusRefreshing;
 
   return html`
     <div class="space-y-4">
@@ -117,7 +121,8 @@ export const GeneralTab = ({
                 <${Pairings}
                   pending=${state.pending}
                   channels=${state.channels}
-                  visible=${state.hasUnpaired}
+                  visible=${showPairings}
+                  pollingInFlight=${state.pairingsPolling}
                   statusRefreshing=${state.pairingStatusRefreshing}
                   onApprove=${actions.handleApprove}
                   onReject=${actions.handleReject}

package/lib/public/js/components/general/use-general-tab.js

@@ -56,6 +56,9 @@ export const useGeneralTab = ({
     }
     return info.status !== "paired";
   });
+  const hasConfiguredPairingChannel = ALL_CHANNELS.some((channel) =>
+    Boolean(channels?.[channel]),
+  );
 
   const pairingsPoll = usePolling(
     async () => {
@@ -64,8 +67,9 @@ export const useGeneralTab = ({
     },
     3000,
     {
-      enabled: hasUnpaired && gatewayStatus === "running",
+      enabled: hasConfiguredPairingChannel && gatewayStatus === "running",
       cacheKey: "/api/pairings",
+      dedupeInFlight: true,
     },
   );
   const pending = pairingsPoll.data || [];
@@ -86,25 +90,10 @@ export const useGeneralTab = ({
   );
   const devicePending = devicePoll.data || [];
 
-  useEffect(() => {
-    if (!isActive) return;
-    pairingsPoll.refresh();
-    if (shouldPollDevices) {
-      devicePoll.refresh();
-    }
-  }, [
-    devicePoll.refresh,
-    isActive,
-    onRefreshStatuses,
-    pairingsPoll.refresh,
-    devicePollingEnabled,
-    shouldPollDevices,
-  ]);
-
   useEffect(() => {
     if (!restartSignal || !isActive) return;
     onRefreshStatuses();
-    pairingsPoll.refresh();
+    pairingsPoll.refresh({ force: true });
     if (shouldPollDevices) {
       devicePoll.refresh();
     }
@@ -164,7 +153,7 @@ export const useGeneralTab = ({
       pairingRefreshTimerRef.current = null;
     }, 2800);
     onRefreshStatuses();
-    pairingsPoll.refresh();
+    pairingsPoll.refresh({ force: true });
     setTimeout(() => {
       onRefreshStatuses();
       pairingsPoll.refresh();
@@ -208,8 +197,14 @@ export const useGeneralTab = ({
   };
 
   const handleApprove = async (id, channel, accountId = "") => {
-    await approvePairing(id, channel, accountId);
-    refreshAfterPairingAction();
+    try {
+      const result = await approvePairing(id, channel, accountId);
+      if (!result.ok) throw new Error(result.error || "Could not approve pairing");
+      refreshAfterPairingAction();
+    } catch (err) {
+      showToast(err.message || "Could not approve pairing", "error");
+      throw err;
+    }
   };
 
   const handleReject = async (id, channel, accountId = "") => {
@@ -218,6 +213,7 @@ export const useGeneralTab = ({
       refreshAfterPairingAction();
     } catch (err) {
       showToast(err.message || "Could not reject pairing", "error");
+      throw err;
     }
   };
 
@@ -276,6 +272,7 @@ export const useGeneralTab = ({
       hasUnpaired,
       openclawVersion,
       pending,
+      pairingsPolling: pairingsPoll.isPolling,
       pairingStatusRefreshing,
       repairingWatchdog,
       repo,

package/lib/public/js/components/models-tab/index.js

@@ -10,6 +10,7 @@ import { Badge } from "../badge.js";
 import { useModels } from "./use-models.js";
 import {
   buildProviderHasAuth,
+  buildSyntheticModelEntry,
   getModelCatalogProvider,
   getModelsTabAuthProvider,
   getProviderSortIndex,
@@ -111,12 +112,14 @@ export const Models = ({ onRestartRequired = () => {}, agentId, embedded = false
   const configuredModelEntries = useMemo(
     () =>
       Object.keys(configuredModels).map((key) => {
-        const catalogEntry = catalog.find((m) => m.key === key);
+        const catalogEntry =
+          catalog.find((m) => m.key === key) || buildSyntheticModelEntry(key);
         const provider = getModelsTabAuthProvider(key);
         const hasAuth = !!providerHasAuth[provider];
         return {
           key,
           label: catalogEntry?.label || key,
+          provider: catalogEntry?.provider || provider,
           isPrimary: key === primary,
           hasAuth,
         };
@@ -216,6 +219,7 @@ export const Models = ({ onRestartRequired = () => {}, agentId, embedded = false
         <${SearchableModelPicker}
           options=${pickerModels}
           popularModels=${popularPickerModels}
+          configuredOptions=${configuredModelEntries}
           placeholder="Add model..."
           onSelect=${(modelKey) => {
             addModel(modelKey);

package/lib/public/js/components/models-tab/model-picker.js

@@ -36,6 +36,33 @@ const formatProviderSectionLabel = (provider) =>
 
 const normalizeSearch = (value) => String(value || "").trim().toLowerCase();
 
+const titleCaseToken = (value) => {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (!normalized) return "";
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+};
+
+const formatAnthropicModelLabel = (modelId) => {
+  const match = /^claude-(opus|sonnet|haiku)-(\d+)[-.](\d+)$/i.exec(
+    String(modelId || "").trim(),
+  );
+  if (!match) return "";
+  return `Claude ${titleCaseToken(match[1])} ${match[2]}.${match[3]}`;
+};
+
+export const buildSyntheticModelEntry = (modelKey) => {
+  const key = String(modelKey || "").trim();
+  const provider = getModelProvider(key);
+  const modelId = key.includes("/") ? key.split("/").slice(1).join("/") : key;
+  const anthropicLabel =
+    provider === "anthropic" ? formatAnthropicModelLabel(modelId) : "";
+  return {
+    key,
+    provider,
+    label: anthropicLabel || key,
+  };
+};
+
 export const getModelDisplayLabel = (model) => model?.featuredLabel || model?.label || model?.key;
 
 const buildModelSearchText = (model) =>
@@ -67,6 +94,7 @@ export const buildProviderHasAuth = ({
 export const SearchableModelPicker = ({
   options = [],
   popularModels = [],
+  configuredOptions = [],
   placeholder = "Add model...",
   onSelect = () => {},
   disabled = false,
@@ -84,6 +112,15 @@ export const SearchableModelPicker = ({
         : options,
     [options, normalizedQuery],
   );
+  const matchingConfiguredOptions = useMemo(
+    () =>
+      normalizedQuery
+        ? configuredOptions.filter((option) =>
+            buildModelSearchText(option).includes(normalizedQuery),
+          )
+        : [],
+    [configuredOptions, normalizedQuery],
+  );
   const groupedOptions = useMemo(() => {
     const groups = [];
     const showPopularGroup = !normalizedQuery;
@@ -198,6 +235,21 @@ export const SearchableModelPicker = ({
                         </div>
                       `,
                     )
+                  : matchingConfiguredOptions.length > 0
+                    ? html`
+                        <div class="px-3 py-3 text-xs text-fg-muted">
+                          ${matchingConfiguredOptions.length === 1
+                            ? html`
+                                Already added above:
+                                <span class="text-body">
+                                  ${getModelDisplayLabel(
+                                    matchingConfiguredOptions[0],
+                                  )}
+                                </span>
+                              `
+                            : `${matchingConfiguredOptions.length} matching models are already added above.`}
+                        </div>
+                      `
                   : html`
                       <div class="px-3 py-3 text-xs text-fg-muted">
                         No models match that search.

package/lib/public/js/components/onboarding/use-welcome-pairing.js

@@ -20,7 +20,10 @@ export const useWelcomePairing = ({
       return allPending.filter((p) => p.channel === selectedPairingChannel);
     },
     1000,
-    { enabled: isPairingStep && !!selectedPairingChannel },
+    {
+      enabled: isPairingStep && !!selectedPairingChannel,
+      dedupeInFlight: true,
+    },
   );
   const pairingChannels = pairingStatusPoll.data?.channels || {};
   const canFinishPairing = isChannelPaired(pairingChannels, selectedPairingChannel);

package/lib/public/js/components/pairings.js

@@ -1,7 +1,8 @@
 import { h } from 'preact';
-import { useState } from 'preact/hooks';
+import { useEffect, useState } from 'preact/hooks';
 import htm from 'htm';
 import { ActionButton } from './action-button.js';
+import { LoadingSpinner } from './loading-spinner.js';
 const html = htm.bind(h);
 
 export const PairingRow = ({ p, onApprove, onReject }) => {
@@ -66,6 +67,13 @@ const ALL_CHANNELS = ['telegram', 'discord', 'slack', 'whatsapp'];
 
 const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
 
+const getPairingKey = (p) => {
+  const channel = String(p?.channel || "").trim().toLowerCase();
+  const accountId = String(p?.accountId || "").trim() || "default";
+  const id = String(p?.id || p?.code || "").trim();
+  return channel && id ? `${channel}\u0000${accountId}\u0000${id}` : "";
+};
+
 export function Pairings({
   pending,
   channels,
@@ -73,7 +81,52 @@ export function Pairings({
   onApprove,
   onReject,
   statusRefreshing = false,
+  pollingInFlight = false,
 }) {
+  const [hiddenPairingKeys, setHiddenPairingKeys] = useState(() => new Set());
+  const pendingList = Array.isArray(pending) ? pending : [];
+
+  useEffect(() => {
+    setHiddenPairingKeys((current) => {
+      if (current.size === 0) return current;
+      const pendingKeys = new Set(
+        pendingList.map(getPairingKey).filter(Boolean),
+      );
+      const next = new Set();
+      for (const key of current) {
+        if (pendingKeys.has(key)) {
+          next.add(key);
+        }
+      }
+      return next.size === current.size ? current : next;
+    });
+  }, [pending]);
+
+  const hidePairing = (p) => {
+    const key = getPairingKey(p);
+    if (!key) return;
+    setHiddenPairingKeys((current) => {
+      if (current.has(key)) return current;
+      const next = new Set(current);
+      next.add(key);
+      return next;
+    });
+  };
+
+  const handleApprove = async (p) => {
+    await onApprove(p.id, p.channel, p.accountId);
+    hidePairing(p);
+  };
+
+  const handleReject = async (p) => {
+    await onReject(p.id, p.channel, p.accountId);
+    hidePairing(p);
+  };
+
+  const visiblePending = pendingList.filter(
+    (p) => !hiddenPairingKeys.has(getPairingKey(p)),
+  );
+
   if (!visible) return null;
 
   const unpaired = ALL_CHANNELS
@@ -95,12 +148,30 @@ export function Pairings({
     ? unpaired.join(' or ')
     : unpaired.slice(0, -1).join(', ') + ', or ' + unpaired[unpaired.length - 1];
 
+  if (unpaired.length === 0 && visiblePending.length === 0) return null;
+
   return html`
     <div class="bg-surface border border-border rounded-xl p-4">
-      <h2 class="card-label mb-3">Pending Pairings</h2>
-      ${pending.length > 0
+      <div class="flex items-center justify-between gap-3 mb-3">
+        <h2 class="card-label">Pending Pairings</h2>
+        ${pollingInFlight
+          ? html`
+              <div class="inline-flex items-center text-fg-muted" aria-label="Pairings refresh in progress">
+                <${LoadingSpinner} className="h-3.5 w-3.5 text-fg-muted" />
+              </div>
+            `
+          : null}
+      </div>
+      ${visiblePending.length > 0
         ? html`<div>
-            ${pending.map(p => html`<${PairingRow} key=${p.id} p=${p} onApprove=${onApprove} onReject=${onReject} />`)}
+            ${visiblePending.map((p) => html`
+              <${PairingRow}
+                key=${getPairingKey(p) || p.id}
+                p=${p}
+                onApprove=${() => handleApprove(p)}
+                onReject=${() => handleReject(p)}
+              />
+            `)}
           </div>`
         : statusRefreshing
         ? html`<div class="text-center py-4 space-y-2">

package/lib/public/js/components/welcome/use-welcome.js

@@ -1,4 +1,4 @@
-import { useEffect, useState } from "preact/hooks";
+import { useCallback, useEffect, useState } from "preact/hooks";
 import {
   runOnboard,
   verifyGithubOnboardingRepo,
@@ -7,6 +7,7 @@ import {
   fetchModels,
 } from "../../lib/api.js";
 import { useCachedFetch } from "../../hooks/use-cached-fetch.js";
+import { usePolling } from "../../hooks/usePolling.js";
 import {
   getModelProvider,
   getAuthProviderFromModelProvider,
@@ -17,7 +18,9 @@ import {
 import {
   getInitialOnboardingModelKey,
   getModelCatalogModels,
+  isModelCatalogRefreshing,
   kModelCatalogCacheKey,
+  kModelCatalogPollIntervalMs,
   preloadModelCatalog,
 } from "../../lib/model-catalog.js";
 import {
@@ -100,6 +103,7 @@ export const useWelcome = ({ onComplete }) => {
   const [models, setModels] = useState([]);
   const [modelsLoading, setModelsLoading] = useState(true);
   const [modelsError, setModelsError] = useState(null);
+  const [modelsRefreshing, setModelsRefreshing] = useState(false);
   const [showAllModels, setShowAllModels] = useState(false);
   const [loading, setLoading] = useState(false);
   const [githubStepLoading, setGithubStepLoading] = useState(false);
@@ -129,6 +133,11 @@ export const useWelcome = ({ onComplete }) => {
   const modelsFetchState = useCachedFetch(kModelCatalogCacheKey, fetchModels, {
     maxAgeMs: 30000,
   });
+  const modelsPoll = usePolling(fetchModels, kModelCatalogPollIntervalMs, {
+    enabled: modelsRefreshing,
+    pauseWhenHidden: true,
+    cacheKey: kModelCatalogCacheKey,
+  });
 
   useEffect(() => {
     // Warm the real catalog immediately so the AI step usually opens ready.
@@ -157,11 +166,21 @@ export const useWelcome = ({ onComplete }) => {
     }));
   };
 
-  useEffect(() => {
-    const list = getModelCatalogModels(modelsFetchState.data);
-    if (!modelsFetchState.data) return;
+  const applyModelCatalog = useCallback((payload) => {
+    const list = getModelCatalogModels(payload);
+    if (!payload) return;
+    const isRefreshing = isModelCatalogRefreshing(payload);
+    const isFallbackRefresh =
+      String(payload?.source || "") === "fallback" && isRefreshing;
     setModels(list);
-    setModelsError(list.length > 0 ? null : "No models found");
+    setModelsRefreshing(isRefreshing);
+    setModelsError(
+      list.length > 0
+        ? isFallbackRefresh
+          ? "Loading full model catalog..."
+          : null
+        : "No models found",
+    );
     const defaultModelKey = getInitialOnboardingModelKey({
       catalog: list,
       currentModelKey: vals.MODEL_KEY,
@@ -169,12 +188,22 @@ export const useWelcome = ({ onComplete }) => {
     if (!vals.MODEL_KEY && defaultModelKey) {
       setVals((prev) => ({ ...prev, MODEL_KEY: defaultModelKey }));
     }
-  }, [modelsFetchState.data, setVals, vals.MODEL_KEY]);
+  }, [setVals, vals.MODEL_KEY]);
+
+  useEffect(() => {
+    applyModelCatalog(modelsFetchState.data);
+  }, [applyModelCatalog, modelsFetchState.data]);
+
+  useEffect(() => {
+    applyModelCatalog(modelsPoll.data);
+  }, [applyModelCatalog, modelsPoll.data]);
 
   useEffect(() => {
     const hasModels = getModelCatalogModels(modelsFetchState.data).length > 0;
-    setModelsLoading(modelsFetchState.loading && !hasModels);
-  }, [modelsFetchState.data, modelsFetchState.loading]);
+    setModelsLoading(
+      (modelsFetchState.loading || modelsPoll.isPolling) && !hasModels,
+    );
+  }, [modelsFetchState.data, modelsFetchState.loading, modelsPoll.isPolling]);
 
   useEffect(() => {
     if (!modelsFetchState.error) return;

package/lib/public/js/hooks/usePolling.js

@@ -8,6 +8,7 @@ export const usePolling = (
     enabled = true,
     pauseWhenHidden = true,
     cacheKey = "",
+    dedupeInFlight = false,
   } = {},
 ) => {
   const normalizedCacheKey = String(cacheKey || "");
@@ -15,23 +16,55 @@ export const usePolling = (
     normalizedCacheKey ? getCached(normalizedCacheKey) : null,
   );
   const [error, setError] = useState(null);
+  const [isPolling, setIsPolling] = useState(false);
   const fetcherRef = useRef(fetcher);
+  const inFlightRefreshRef = useRef(null);
+  const activeRefreshCountRef = useRef(0);
+  const nextRefreshIdRef = useRef(0);
+  const latestRefreshIdRef = useRef(0);
   fetcherRef.current = fetcher;
 
-  const refresh = useCallback(async () => {
-    try {
-      const result = await fetcherRef.current();
-      if (normalizedCacheKey) {
-        setCached(normalizedCacheKey, result);
+  const refresh = useCallback(async ({ force = false } = {}) => {
+    if (dedupeInFlight && inFlightRefreshRef.current && !force) {
+      return inFlightRefreshRef.current;
+    }
+    const refreshId = nextRefreshIdRef.current + 1;
+    nextRefreshIdRef.current = refreshId;
+    latestRefreshIdRef.current = refreshId;
+    activeRefreshCountRef.current += 1;
+    setIsPolling(true);
+    const refreshPromise = Promise.resolve().then(async () => {
+      try {
+        const result = await fetcherRef.current();
+        if (latestRefreshIdRef.current === refreshId) {
+          if (normalizedCacheKey) {
+            setCached(normalizedCacheKey, result);
+          }
+          setData(result);
+          setError(null);
+        }
+        return result;
+      } catch (err) {
+        if (latestRefreshIdRef.current === refreshId) {
+          setError(err);
+        }
+        return null;
+      } finally {
+        activeRefreshCountRef.current = Math.max(
+          0,
+          activeRefreshCountRef.current - 1,
+        );
+        setIsPolling(activeRefreshCountRef.current > 0);
+        if (inFlightRefreshRef.current === refreshPromise) {
+          inFlightRefreshRef.current = null;
+        }
       }
-      setData(result);
-      setError(null);
-      return result;
-    } catch (err) {
-      setError(err);
-      return null;
+    });
+    if (dedupeInFlight) {
+      inFlightRefreshRef.current = refreshPromise;
     }
-  }, [normalizedCacheKey]);
+    return refreshPromise;
+  }, [dedupeInFlight, normalizedCacheKey]);
 
   useEffect(() => {
     if (!normalizedCacheKey) return;
@@ -63,5 +96,5 @@ export const usePolling = (
       document.removeEventListener("visibilitychange", handleVisibilityChange);
   }, [enabled, pauseWhenHidden, refresh]);
 
-  return { data, error, refresh };
+  return { data, error, refresh, isPolling };
 };