Skip to content

Commit f6cf66b

Browse files
committed
fix(quota): Paginate /v1/me/usage from midnight UTC
The /v1/me/usage endpoint defaults to a 10-event page (max 100), so the rpd/tpd gauge silently undercounted heavy days — a user with 50+ calls saw "tpd 226k/1.3M" while the server actually had them at 100% and replied with daily-quota 429s. fetch_albert_usage now accepts a since_timestamp parameter and paginates via offset until the server returns a short page, capped at 100 pages as a runaway guard. The two existing call sites (startup quota warning and the 30s poller) pass midnight UTC so we walk only today's events.
1 parent 48457c5 commit f6cf66b

3 files changed

Lines changed: 163 additions & 26 deletions

File tree

‎albert_code/cli/textual_ui/app.py‎

Lines changed: 11 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1738,6 +1738,7 @@ async def _check_quota_warning(self) -> None:
17381738
documented_limits_for,
17391739
fetch_albert_usage,
17401740
is_albert_provider,
1741+
midnight_utc_timestamp,
17411742
sum_prompt_tokens_today,
17421743
)
17431744
from albert_code.core.llm.quota_state import (
@@ -1770,8 +1771,12 @@ async def _check_quota_warning(self) -> None:
17701771
f"`{active_model.name}`, may be unaffected)."
17711772
)
17721773

1773-
# A - live /me/usage estimation
1774-
usage = await fetch_albert_usage(provider)
1774+
# A - live /me/usage estimation. Paginate from today's midnight
1775+
# UTC so we count every call of the day; the server-side default
1776+
# page is just 10 events, which silently undercounts heavy days.
1777+
usage = await fetch_albert_usage(
1778+
provider, since_timestamp=midnight_utc_timestamp()
1779+
)
17751780
documented = documented_limits_for(active_model.name)
17761781
if usage is not None and documented is not None and documented.exp.tpd:
17771782
used_today = sum_prompt_tokens_today(usage, active_model.name)
@@ -1833,6 +1838,7 @@ async def _poll_daily_usage_loop(self) -> None:
18331838
count_requests_today,
18341839
fetch_albert_usage,
18351840
is_albert_provider,
1841+
midnight_utc_timestamp,
18361842
sum_prompt_tokens_today,
18371843
)
18381844
from albert_code.core.llm.throttling import get_throttler
@@ -1842,7 +1848,9 @@ async def _poll_daily_usage_loop(self) -> None:
18421848
active_model = self.config.get_active_model()
18431849
provider = self.config.get_provider_for_model(active_model)
18441850
if is_albert_provider(provider):
1845-
events = await fetch_albert_usage(provider)
1851+
events = await fetch_albert_usage(
1852+
provider, since_timestamp=midnight_utc_timestamp()
1853+
)
18461854
if events is not None:
18471855
throttler = get_throttler(provider)
18481856
# /v1/me/usage events carry the canonical id, never

‎albert_code/core/llm/quota.py‎

Lines changed: 62 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -64,33 +64,84 @@ def is_albert_provider(provider: ProviderConfig) -> bool:
6464
return provider.name == ALBERT_PROVIDER_NAME
6565

6666

67+
def midnight_utc_timestamp() -> int:
68+
"""Today's 00:00 UTC as a Unix timestamp.
69+
70+
Albert daily quotas (rpd/tpd) reset at this boundary, so the tpd/rpd
71+
gauges only need events past this point.
72+
"""
73+
import datetime as dt
74+
75+
return int(
76+
dt.datetime.now(dt.UTC)
77+
.replace(hour=0, minute=0, second=0, microsecond=0)
78+
.timestamp()
79+
)
80+
81+
82+
# Server-imposed page size cap (see /v1/me/usage OpenAPI schema). Higher
83+
# values are rejected with 422.
84+
_USAGE_PAGE_LIMIT = 100
85+
# Hard ceiling on the number of pages we'll fetch, to prevent a runaway
86+
# loop if the server ever stops honouring the "fewer rows than limit
87+
# means last page" convention. 100 pages * 100 rows = 10 000 events,
88+
# more than enough for one day at the documented EXP tier (1000 rpd).
89+
_USAGE_MAX_PAGES = 100
90+
91+
6792
async def fetch_albert_usage(
68-
provider: ProviderConfig, *, timeout: float = 10.0
93+
provider: ProviderConfig,
94+
*,
95+
since_timestamp: int | None = None,
96+
timeout: float = 10.0,
6997
) -> list[dict[str, object]] | None:
7098
"""Fetch /v1/me/usage. Returns the list of usage events, or None on failure.
7199
72-
Albert returns a list of recent calls with their token counts; the
73-
payload schema is `{object: "list", data: [...]}`. We just hand back
74-
`data` as a list of dicts and let callers slice what they need.
100+
Albert returns `{object: "list", data: [...]}` with a default page
101+
size of 10 (cap 100). When `since_timestamp` is provided, we pass it
102+
as `start_time` and paginate via `offset` until the server returns a
103+
short page — this is required for the tpd/rpd gauges to be accurate
104+
once the user has done more than 10 calls in the day. Without
105+
`since_timestamp` the function keeps its legacy single-page
106+
behaviour for back-compat.
75107
"""
76108
if _check_albert_preconditions(provider) is not None:
77109
return None
78110
api_key = os.getenv(provider.api_key_env_var) or ""
79111
url = f"{provider.api_base.rstrip('/')}/me/usage"
80112
headers = {"Authorization": f"Bearer {api_key}", "Accept": "application/json"}
113+
all_events: list[dict[str, object]] = []
81114
try:
82115
async with httpx.AsyncClient(timeout=httpx.Timeout(timeout)) as client:
83-
response = await client.get(url, headers=headers)
84-
response.raise_for_status()
85-
payload = response.json()
116+
offset = 0
117+
for _ in range(_USAGE_MAX_PAGES):
118+
params: dict[str, int] = {
119+
"limit": _USAGE_PAGE_LIMIT,
120+
"offset": offset,
121+
}
122+
if since_timestamp is not None:
123+
params["start_time"] = since_timestamp
124+
response = await client.get(url, headers=headers, params=params)
125+
response.raise_for_status()
126+
payload = response.json()
127+
data = payload.get("data") if isinstance(payload, dict) else None
128+
if not isinstance(data, list):
129+
return None
130+
all_events.extend(data)
131+
if since_timestamp is None or len(data) < _USAGE_PAGE_LIMIT:
132+
return all_events
133+
offset += len(data)
134+
logger.warning(
135+
"Albert /me/usage: pagination hit safety cap (%d pages)",
136+
_USAGE_MAX_PAGES,
137+
)
138+
return all_events
86139
except httpx.HTTPError as exc:
87140
logger.debug("Albert /me/usage fetch failed: %s", exc)
88141
return None
89142
except ValueError as exc:
90143
logger.debug("Albert /me/usage returned non-JSON: %s", exc)
91144
return None
92-
data = payload.get("data") if isinstance(payload, dict) else None
93-
return data if isinstance(data, list) else None
94145

95146

96147
def sum_prompt_tokens_today(
@@ -101,13 +152,7 @@ def sum_prompt_tokens_today(
101152
Daily quotas reset at midnight UTC, so any event before today's
102153
00:00 UTC doesn't consume the running counter.
103154
"""
104-
import datetime as dt
105-
106-
midnight_utc = (
107-
dt.datetime.now(dt.UTC)
108-
.replace(hour=0, minute=0, second=0, microsecond=0)
109-
.timestamp()
110-
)
155+
midnight_utc = midnight_utc_timestamp()
111156
total = 0
112157
for event in usage_events:
113158
if not isinstance(event, dict):
@@ -131,13 +176,7 @@ def count_requests_today(usage_events: list[dict[str, object]], model_name: str)
131176
Mirror of `sum_prompt_tokens_today` for the rpd (requests per day)
132177
counter: each event past midnight UTC counts for one request.
133178
"""
134-
import datetime as dt
135-
136-
midnight_utc = (
137-
dt.datetime.now(dt.UTC)
138-
.replace(hour=0, minute=0, second=0, microsecond=0)
139-
.timestamp()
140-
)
179+
midnight_utc = midnight_utc_timestamp()
141180
count = 0
142181
for event in usage_events:
143182
if not isinstance(event, dict):

‎tests/core/test_quota.py‎

Lines changed: 90 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
RouterLimit,
1111
fetch_albert_quotas,
1212
fetch_albert_quotas_detailed,
13+
fetch_albert_usage,
1314
group_limits_by_router,
1415
is_albert_provider,
1516
)
@@ -191,3 +192,92 @@ async def test_fetch_albert_quotas_detailed_explains_http_error(
191192
assert info is None
192193
assert error is not None
193194
assert "404" in error
195+
196+
197+
def _usage_page(n: int) -> dict[str, object]:
198+
return {
199+
"object": "list",
200+
"data": [
201+
{
202+
"object": "me.usage",
203+
"model": "openai/gpt-oss-120b",
204+
"usage": {"prompt_tokens": 1000},
205+
"created": 1_778_261_739,
206+
}
207+
for _ in range(n)
208+
],
209+
}
210+
211+
212+
@pytest.mark.asyncio
213+
async def test_fetch_albert_usage_legacy_single_call(
214+
monkeypatch: pytest.MonkeyPatch, respx_mock: respx.MockRouter
215+
) -> None:
216+
# Without `since_timestamp` we keep the legacy single-page behaviour.
217+
# Even if the server returned a full 100-event page, we MUST NOT
218+
# paginate, to stay back-compatible with the original signature.
219+
monkeypatch.setenv("TEST_ALBERT_KEY", "secret")
220+
route = respx_mock.get("http://test/v1/me/usage").mock(
221+
return_value=httpx.Response(200, json=_usage_page(100))
222+
)
223+
events = await fetch_albert_usage(_make_provider())
224+
assert events is not None
225+
assert len(events) == 100
226+
assert route.call_count == 1
227+
228+
229+
@pytest.mark.asyncio
230+
async def test_fetch_albert_usage_paginates_until_short_page(
231+
monkeypatch: pytest.MonkeyPatch, respx_mock: respx.MockRouter
232+
) -> None:
233+
# Reproduces the user-reported scenario: the day has 230 events,
234+
# the server caps page size at 100, so the previous single-call
235+
# implementation only saw 10 of them and the tpd gauge undercounted
236+
# by 5x. With pagination we must walk all three pages.
237+
monkeypatch.setenv("TEST_ALBERT_KEY", "secret")
238+
responses = [
239+
httpx.Response(200, json=_usage_page(100)),
240+
httpx.Response(200, json=_usage_page(100)),
241+
httpx.Response(200, json=_usage_page(30)),
242+
]
243+
route = respx_mock.get("http://test/v1/me/usage").mock(side_effect=responses)
244+
events = await fetch_albert_usage(_make_provider(), since_timestamp=1_000_000)
245+
assert events is not None
246+
assert len(events) == 230
247+
assert route.call_count == 3
248+
offsets = [c.request.url.params.get("offset") for c in route.calls]
249+
assert offsets == ["0", "100", "200"]
250+
# start_time must be forwarded on every page so the server keeps
251+
# filtering consistently (otherwise pages 2+ would drift).
252+
start_times = {c.request.url.params.get("start_time") for c in route.calls}
253+
assert start_times == {"1000000"}
254+
limits = {c.request.url.params.get("limit") for c in route.calls}
255+
assert limits == {"100"}
256+
257+
258+
@pytest.mark.asyncio
259+
async def test_fetch_albert_usage_stops_on_first_short_page(
260+
monkeypatch: pytest.MonkeyPatch, respx_mock: respx.MockRouter
261+
) -> None:
262+
# When the day has fewer events than the page size, a single call
263+
# is enough — we must NOT issue a wasteful empty second page.
264+
monkeypatch.setenv("TEST_ALBERT_KEY", "secret")
265+
route = respx_mock.get("http://test/v1/me/usage").mock(
266+
return_value=httpx.Response(200, json=_usage_page(42))
267+
)
268+
events = await fetch_albert_usage(_make_provider(), since_timestamp=1_000_000)
269+
assert events is not None
270+
assert len(events) == 42
271+
assert route.call_count == 1
272+
273+
274+
@pytest.mark.asyncio
275+
async def test_fetch_albert_usage_returns_none_on_http_error(
276+
monkeypatch: pytest.MonkeyPatch, respx_mock: respx.MockRouter
277+
) -> None:
278+
monkeypatch.setenv("TEST_ALBERT_KEY", "secret")
279+
respx_mock.get("http://test/v1/me/usage").mock(
280+
return_value=httpx.Response(500, json={"detail": "boom"})
281+
)
282+
assert await fetch_albert_usage(_make_provider()) is None
283+

0 commit comments

Comments
 (0)