Skip to content

Commit 5b3b905

Browse files
committed
fix(usage): refresh limits when the tab opens
1 parent 2a264ad commit 5b3b905

7 files changed

Lines changed: 221 additions & 29 deletions

File tree

‎apps/mobile/src/features/usage/UsageLimitsSection.tsx‎

Lines changed: 50 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,8 @@ import {
1616
paceOf,
1717
remainingPercent,
1818
} from "@t3tools/shared/usageLimits";
19-
import { type ReactNode, useState } from "react";
19+
import { type ReactNode, useEffect, useEffectEvent, useRef, useState } from "react";
20+
import { refreshUsageLimits } from "@t3tools/client-runtime/state/usage";
2021
import { Alert, Pressable, View } from "react-native";
2122

2223
import { AppText as Text } from "../../components/AppText";
@@ -279,47 +280,86 @@ export function ResetCredits(props: {
279280
* Environments whose probe failed are named, since their rows keep showing
280281
* the previous quota with nothing else to say so.
281282
*/
282-
export function useRefreshLimits(selectedEnvironmentIds: ReadonlySet<EnvironmentId> | null = null) {
283+
export function useRefreshLimits(
284+
selectedEnvironmentIds: ReadonlySet<EnvironmentId> | null = null,
285+
active = false,
286+
) {
283287
const presentations = useAtomValue(environmentPresentations.presentationsAtom);
284288
const refreshProviders = useAtomCommand(serverEnvironment.refreshProviders, {
285289
reportFailure: false,
286290
});
287291
const [now, setNow] = useState(() => Date.now());
288292
const [refreshing, setRefreshing] = useState(false);
293+
const refreshingRef = useRef(false);
289294
const [failedEnvironments, setFailedEnvironments] = useState<
290295
readonly { environmentId: EnvironmentId; label: string }[]
291296
>([]);
292-
// Always toggles `refreshing`, even with nothing to probe: Android's
293-
// RefreshControl keeps its spinner up until it sees true then false.
294-
const refresh = async () => {
297+
const refresh = async (automatic = false) => {
295298
const connected = [...presentations].filter(
296299
([environmentId, presentation]) =>
297300
presentation.connection.phase === "connected" &&
298301
(selectedEnvironmentIds === null || selectedEnvironmentIds.has(environmentId)),
299302
);
300-
setRefreshing(true);
301303
try {
302304
const results = await Promise.all(
303-
connected.map(([environmentId]) => refreshProviders({ environmentId, input: {} })),
305+
connected.map(([environmentId]) =>
306+
refreshUsageLimits(
307+
environmentId,
308+
() => refreshProviders({ environmentId, input: {} }),
309+
automatic,
310+
),
311+
),
304312
);
305-
setFailedEnvironments(
313+
setFailedEnvironments((previous) =>
306314
connected
307-
.filter((_, index) => results[index]?._tag === "Failure")
315+
.filter(([environmentId], index) =>
316+
results[index] === undefined
317+
? previous.some((failed) => failed.environmentId === environmentId)
318+
: results[index]?._tag === "Failure",
319+
)
308320
.map(([environmentId, presentation]) => ({
309321
environmentId,
310322
label: presentation.entry.target.label,
311323
})),
312324
);
313325
} finally {
314326
setNow(Date.now());
327+
}
328+
};
329+
// Always toggles `refreshing`, even with nothing to probe: Android's
330+
// RefreshControl keeps its spinner up until it sees true then false.
331+
const refreshManually = async () => {
332+
if (refreshingRef.current) return;
333+
refreshingRef.current = true;
334+
setRefreshing(true);
335+
try {
336+
await refresh();
337+
} finally {
338+
refreshingRef.current = false;
315339
setRefreshing(false);
316340
}
317341
};
342+
const connectedLimitsEnvironments = [...presentations]
343+
.filter(
344+
([environmentId, presentation]) =>
345+
presentation.connection.phase === "connected" &&
346+
(selectedEnvironmentIds === null || selectedEnvironmentIds.has(environmentId)),
347+
)
348+
.map(([environmentId]) => environmentId)
349+
.sort()
350+
.join(",");
351+
const autoRefreshLimits = useEffectEvent(() => {
352+
void refresh(true);
353+
});
354+
useEffect(() => {
355+
if (active && connectedLimitsEnvironments) autoRefreshLimits();
356+
}, [active, connectedLimitsEnvironments]);
357+
318358
const failedLabels = failedEnvironments
319359
.filter(
320360
({ environmentId }) =>
321361
selectedEnvironmentIds === null || selectedEnvironmentIds.has(environmentId),
322362
)
323363
.map(({ label }) => label);
324-
return { now, refreshing, failedLabels, refresh };
364+
return { now, refreshing, failedLabels, refresh: refreshManually };
325365
}

‎apps/mobile/src/features/usage/UsageRouteScreen.tsx‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
import { EnvironmentId, USAGE_CONTRACT_VERSION } from "@t3tools/contracts";
2-
import { type RouteProp, useNavigation, useRoute } from "@react-navigation/native";
2+
import { type RouteProp, useIsFocused, useNavigation, useRoute } from "@react-navigation/native";
33
import {
44
isCompatibleUsageContractVersion,
55
isModelCostUnknown,
@@ -95,7 +95,8 @@ export function UsageRouteScreen() {
9595
window,
9696
selectedEnvironmentIds,
9797
);
98-
const limits = useRefreshLimits(selectedEnvironmentIds);
98+
const isFocused = useIsFocused();
99+
const limits = useRefreshLimits(selectedEnvironmentIds, isFocused && tab === "limits");
99100

100101
const days = useMemo(
101102
() => enumerateDays(window.sinceDay, window.untilDay),

‎apps/web/src/components/usage/UsagePage.refresh.test.tsx‎

Lines changed: 70 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,13 @@
11
import { EnvironmentId, ProviderInstanceId, USAGE_CONTRACT_VERSION } from "@t3tools/contracts";
22
import { mergeUsage } from "@t3tools/shared/usageMerge";
3-
import { act } from "react";
3+
import { StrictMode, act } from "react";
44
import { create, type ReactTestRenderer } from "react-test-renderer";
55
import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test";
66

77
const state = vi.hoisted(() => ({
88
presentations: new Map(),
99
refreshProviders: vi.fn(async () => undefined),
10+
metric: "limits",
1011
}));
1112
vi.mock("@effect/atom-react", () => ({ useAtomValue: () => state.presentations }));
1213
vi.mock("../../state/presentation", () => ({
@@ -43,7 +44,7 @@ vi.mock("../../state/usage", () => ({
4344
}),
4445
}));
4546
vi.mock("./usagePagePreferences", () => ({
46-
readUsagePagePreferences: () => ({ metric: "limits", windowDays: 30 }),
47+
readUsagePagePreferences: () => ({ metric: state.metric, windowDays: 30 }),
4748
saveUsagePagePreferences: vi.fn(),
4849
}));
4950
vi.mock("../ui/button", () => ({ Button: "button" }));
@@ -83,13 +84,16 @@ vi.mock("../settings/providerDriverMeta", () => ({ getDriverOption: () => ({ lab
8384
import { UsagePage } from "./UsagePage";
8485

8586
let renderer: ReactTestRenderer;
87+
let environmentNumber = 0;
8688
beforeEach(() => {
8789
vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
8890
vi.spyOn(Date, "now").mockReturnValue(Date.parse("2026-09-11T12:00:00Z"));
91+
environmentNumber += 1;
92+
state.metric = "limits";
8993
state.refreshProviders.mockClear();
9094
state.presentations = new Map([
9195
[
92-
EnvironmentId.make("test"),
96+
EnvironmentId.make(`test-${environmentNumber}`),
9397
{
9498
entry: { target: { label: "Test" } },
9599
connection: { phase: "connected" },
@@ -150,7 +154,10 @@ it.each([0, 1])(
150154
.at(buttonIndex)!
151155
.props.onClick();
152156
});
153-
expect(state.refreshProviders).toHaveBeenCalledWith({ environmentId: "test", input: {} });
157+
expect(state.refreshProviders).toHaveBeenCalledWith({
158+
environmentId: `test-${environmentNumber}`,
159+
input: {},
160+
});
154161
expect(
155162
JSON.stringify(renderer.toJSON(), (key, value) => (key === "props" ? undefined : value)),
156163
).toContain("in 1h 30m");
@@ -175,5 +182,64 @@ it("uses the current time when returning to limits from tokens", async () => {
175182
expect(
176183
JSON.stringify(renderer.toJSON(), (key, value) => (key === "props" ? undefined : value)),
177184
).toContain("in 1h 0m");
185+
expect(state.refreshProviders).toHaveBeenCalledTimes(2);
186+
});
187+
188+
it("refreshes once on opening Limits and suppresses rapid returns and remounts", async () => {
189+
state.metric = "tokens";
190+
await act(() => {
191+
renderer = create(
192+
<StrictMode>
193+
<UsagePage />
194+
</StrictMode>,
195+
);
196+
});
197+
expect(state.refreshProviders).not.toHaveBeenCalled();
198+
const selectMetric = (metric: string) =>
199+
renderer.root
200+
.findAll((node) => node.type === "div" && node.props["aria-label"] === "Usage metric")[0]!
201+
.props.onValueChange([metric]);
202+
await act(() => selectMetric("limits"));
203+
expect(state.refreshProviders).toHaveBeenCalledTimes(1);
204+
await act(() => selectMetric("tokens"));
205+
await act(() => selectMetric("limits"));
206+
await act(() => renderer.unmount());
207+
state.metric = "limits";
208+
await act(() => {
209+
renderer = create(
210+
<StrictMode>
211+
<UsagePage />
212+
</StrictMode>,
213+
);
214+
});
215+
expect(state.refreshProviders).toHaveBeenCalledTimes(1);
216+
await act(() => selectMetric("tokens"));
217+
vi.mocked(Date.now).mockReturnValue(Date.parse("2026-09-11T12:05:00Z"));
218+
await act(() => selectMetric("limits"));
219+
expect(state.refreshProviders).toHaveBeenCalledTimes(2);
220+
});
221+
222+
it("waits for connection and refreshes new environments during a slow refresh", async () => {
223+
const [id, presentation] = [...state.presentations][0]!;
224+
state.presentations = new Map([[id, { ...presentation, connection: { phase: "disconnected" } }]]);
225+
await act(() => {
226+
renderer = create(<UsagePage />);
227+
});
178228
expect(state.refreshProviders).not.toHaveBeenCalled();
229+
let finishRefresh!: () => void;
230+
state.refreshProviders.mockImplementationOnce(
231+
() =>
232+
new Promise<undefined>((resolve) => {
233+
finishRefresh = () => resolve(undefined);
234+
}),
235+
);
236+
state.presentations = new Map([[id, presentation]]);
237+
await act(() => renderer.update(<UsagePage />));
238+
expect(state.refreshProviders).toHaveBeenCalledTimes(1);
239+
const nextId = EnvironmentId.make(`${id}-next`);
240+
state.presentations = new Map([...state.presentations, [nextId, presentation]]);
241+
await act(() => renderer.update(<UsagePage />));
242+
expect(state.refreshProviders).toHaveBeenCalledTimes(2);
243+
expect(state.refreshProviders).toHaveBeenLastCalledWith({ environmentId: nextId, input: {} });
244+
await act(() => finishRefresh());
179245
});

‎apps/web/src/components/usage/UsagePage.tsx‎

Lines changed: 38 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,8 @@ import {
1111
CircleDashedIcon,
1212
SlidersHorizontalIcon,
1313
} from "lucide-react";
14-
import { useMemo, useRef, useState } from "react";
14+
import { useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
15+
import { refreshUsageLimits } from "@t3tools/client-runtime/state/usage";
1516

1617
import {
1718
isCompatibleUsageContractVersion,
@@ -165,21 +166,31 @@ export function UsagePage() {
165166
setPreferences(nextPreferences);
166167
saveUsagePagePreferences(nextPreferences);
167168
};
169+
const refreshLimits = async (automatic = false) => {
170+
try {
171+
await Promise.all(
172+
Array.from(presentations, ([environmentId, presentation]) => {
173+
if (selectedEnvironmentIds !== null && !selectedEnvironmentIds.has(environmentId)) return;
174+
if (presentation.connection.phase === "connected" && presentation.serverConfig !== null) {
175+
return refreshUsageLimits(
176+
environmentId,
177+
() => refreshProviders({ environmentId, input: {} }),
178+
automatic,
179+
);
180+
}
181+
}),
182+
);
183+
} finally {
184+
setLimitsNow(Date.now());
185+
}
186+
};
168187
const refreshWindow = () => {
169188
if (refreshingRef.current) return;
170189

171190
if (showingLimits) {
172191
refreshingRef.current = true;
173192
setIsRefreshing(true);
174-
void Promise.all(
175-
Array.from(presentations, ([environmentId, presentation]) => {
176-
if (selectedEnvironmentIds !== null && !selectedEnvironmentIds.has(environmentId)) return;
177-
if (presentation.connection.phase === "connected" && presentation.serverConfig !== null) {
178-
return refreshProviders({ environmentId, input: {} });
179-
}
180-
}),
181-
).finally(() => {
182-
setLimitsNow(Date.now());
193+
void refreshLimits().finally(() => {
183194
refreshingRef.current = false;
184195
setIsRefreshing(false);
185196
});
@@ -201,6 +212,23 @@ export function UsagePage() {
201212
setIsRefreshing(false);
202213
});
203214
};
215+
const connectedLimitsEnvironments = [...presentations]
216+
.filter(
217+
([environmentId, presentation]) =>
218+
presentation.connection.phase === "connected" &&
219+
presentation.serverConfig !== null &&
220+
(selectedEnvironmentIds === null || selectedEnvironmentIds.has(environmentId)),
221+
)
222+
.map(([environmentId]) => environmentId)
223+
.sort()
224+
.join(",");
225+
const autoRefreshLimits = useEffectEvent(() => {
226+
void refreshLimits(true);
227+
});
228+
useEffect(() => {
229+
if (showingLimits && connectedLimitsEnvironments) autoRefreshLimits();
230+
}, [showingLimits, connectedLimitsEnvironments]);
231+
204232
const windowLabel =
205233
isPast24Hours && window.sinceTime !== undefined && window.untilTime !== undefined
206234
? `${formatDateTimeShort(window.sinceTime, window.timeZone)} to ${formatDateTimeShort(window.untilTime, window.timeZone)}`

‎docs/user/usage.md‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,9 @@ the bar show each account's quota, countdown, and credits. Tap a row to open its
6060
The same account signed in on more than one environment, or reported by a hub as well, counts once.
6161
Filter with the environment dropdown to see what a single machine has.
6262

63-
If a window looks stale, refresh Limits to re-check every provider and hub.
63+
Opening Limits checks the selected connected environments automatically. Each client waits at
64+
least five minutes between automatic checks of an environment, including after a failed check.
65+
If a window still looks stale, refresh Limits to re-check every provider and hub.
6466

6567
Pick `/usage-limits` from the composer's command menu, or send it as a message, to check the
6668
current model's limits without leaving the conversation. The result opens above the composer and

‎packages/client-runtime/src/state/usage.test.ts‎

Lines changed: 38 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,11 +6,11 @@ import {
66
} from "@t3tools/contracts";
77
import * as Effect from "effect/Effect";
88
import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
9-
import { afterEach, describe, expect, it } from "vite-plus/test";
9+
import { afterEach, describe, expect, it, vi } from "vite-plus/test";
1010

1111
import type { EnvironmentPresentation } from "../connection/presentation.ts";
1212
import { EnvironmentRpcUnavailableError } from "../rpc/client.ts";
13-
import { refreshUsage } from "./usage.ts";
13+
import { refreshUsage, refreshUsageLimits } from "./usage.ts";
1414

1515
const input = {
1616
sinceDay: UsageDay.make("2026-09-05"),
@@ -182,3 +182,39 @@ describe("manual usage refresh", () => {
182182
unmount();
183183
});
184184
});
185+
186+
describe("limits refresh cooldown", () => {
187+
it("coalesces in-flight calls and gates automatic refreshes after success or failure", async () => {
188+
const clock = vi.spyOn(Date, "now").mockReturnValue(1_000);
189+
try {
190+
for (const fails of [false, true]) {
191+
const id = EnvironmentId.make(`limits-${fails}`);
192+
const pending = Promise.withResolvers<void>();
193+
const refresh = vi.fn(() => pending.promise);
194+
const first = refreshUsageLimits(id, refresh, true);
195+
await refreshUsageLimits(id, refresh, true);
196+
await refreshUsageLimits(id, refresh);
197+
expect(refresh).toHaveBeenCalledTimes(1);
198+
if (fails) {
199+
pending.reject(new Error("unavailable"));
200+
await expect(first).rejects.toThrow("unavailable");
201+
} else {
202+
pending.resolve();
203+
await first;
204+
}
205+
const next = vi.fn(async () => undefined);
206+
clock.mockReturnValue(300_999);
207+
await refreshUsageLimits(id, next, true);
208+
expect(next).not.toHaveBeenCalled();
209+
clock.mockReturnValue(301_000);
210+
await refreshUsageLimits(id, next, true);
211+
expect(next).toHaveBeenCalledTimes(1);
212+
await refreshUsageLimits(id, next);
213+
expect(next).toHaveBeenCalledTimes(2);
214+
clock.mockReturnValue(1_000);
215+
}
216+
} finally {
217+
clock.mockRestore();
218+
}
219+
});
220+
});

0 commit comments

Comments
 (0)