Skip to content

Commit cea798e

Browse files
jakeleventhalclaude
andcommitted
fix(usage): share one Codex limits read and let complete reads drop buckets
Concurrent usage requests now wait on a single in-flight Codex read instead of each launching a CLI. A complete read replaces the provider's window set so a bucket the account stopped reporting disappears, while partial turn events still merge. An older observation no longer relabels the plan. Co-Authored-By: Claude Fable 5.1 <[email protected]>
1 parent 5e0e94a commit cea798e

2 files changed

Lines changed: 97 additions & 11 deletions

File tree

‎apps/server/src/usage/usageLimits.test.ts‎

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -277,6 +277,36 @@ describe("mergeProviderLimits", () => {
277277
);
278278
});
279279

280+
it("lets a complete reading drop a bucket the account no longer reports", () => {
281+
const spark = {
282+
id: "codex_spark:five_hour",
283+
scope: "Spark",
284+
durationMinutes: 300,
285+
usedPercent: 3,
286+
resetsAt: null,
287+
observedAt: OBSERVED_AT,
288+
};
289+
const weekly = {
290+
id: "seven_day",
291+
scope: null,
292+
durationMinutes: 10_080,
293+
usedPercent: 16,
294+
resetsAt: null,
295+
observedAt: LATER,
296+
};
297+
const previous = { provider: "codex" as const, plan: "Pro", windows: [weekly, spark] };
298+
const next = { provider: "codex" as const, plan: "Pro", windows: [weekly] };
299+
300+
assert.deepStrictEqual(
301+
mergeProviderLimits(previous, next).windows.map((window) => window.id),
302+
["seven_day", "codex_spark:five_hour"],
303+
);
304+
assert.deepStrictEqual(
305+
mergeProviderLimits(previous, next, { complete: true }).windows.map((window) => window.id),
306+
["seven_day"],
307+
);
308+
});
309+
280310
it("never replaces a reading with an older one", () => {
281311
const merged = mergeProviderLimits(
282312
{
@@ -312,6 +342,22 @@ describe("mergeProviderLimits", () => {
312342
assert.strictEqual(merged.windows[0]?.usedPercent, 50);
313343
assert.strictEqual(merged.plan, "Pro");
314344
});
345+
346+
it("keeps the current plan label when an older observation carries a different one", () => {
347+
const window = {
348+
id: "five_hour",
349+
scope: null,
350+
durationMinutes: 300,
351+
usedPercent: 50,
352+
resetsAt: null,
353+
};
354+
const merged = mergeProviderLimits(
355+
{ provider: "codex", plan: "Pro", windows: [{ ...window, observedAt: LATER }] },
356+
{ provider: "codex", plan: "Plus", windows: [{ ...window, observedAt: OBSERVED_AT }] },
357+
);
358+
359+
assert.strictEqual(merged.plan, "Pro");
360+
});
315361
});
316362

317363
describe("resolveCodexRefreshSettings", () => {

‎apps/server/src/usage/usageLimits.ts‎

Lines changed: 51 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@ import {
2222
} from "@t3tools/contracts";
2323
import * as Context from "effect/Context";
2424
import * as DateTime from "effect/DateTime";
25+
import * as Deferred from "effect/Deferred";
2526
import * as Duration from "effect/Duration";
2627
import * as Effect from "effect/Effect";
2728
import * as FileSystem from "effect/FileSystem";
@@ -301,17 +302,30 @@ function observedAtMs(window: UsageLimitWindow): number {
301302
return Number.isNaN(ms) ? Number.NEGATIVE_INFINITY : ms;
302303
}
303304

305+
/** The newest instant among a reading's windows; oldest possible when it has none. */
306+
function latestObservedMs(limits: UsageProviderLimits | undefined): number {
307+
let latest = Number.NEGATIVE_INFINITY;
308+
for (const window of limits?.windows ?? []) latest = Math.max(latest, observedAtMs(window));
309+
return latest;
310+
}
311+
304312
/**
305313
* Folds a new observation into what is already known for the provider. Each
306-
* window is replaced by its newer reading; windows the update did not mention
307-
* are kept, which is what turns Claude's one-window events into a full set.
314+
* window is replaced by its newer reading. A partial update keeps the windows
315+
* it did not mention, which is what turns Claude's one-window events into a
316+
* full set; a complete reading (Codex's on-demand read) replaces the set, so a
317+
* bucket the account stopped reporting disappears.
308318
*/
309319
export function mergeProviderLimits(
310320
previous: UsageProviderLimits | undefined,
311321
next: UsageProviderLimits,
322+
options: { readonly complete?: boolean } = {},
312323
): UsageProviderLimits {
313324
const byId = new Map<string, UsageLimitWindow>();
314-
for (const window of previous?.windows ?? []) byId.set(window.id, window);
325+
if (!options.complete) {
326+
for (const window of previous?.windows ?? []) byId.set(window.id, window);
327+
}
328+
const nextIsNewest = latestObservedMs(next) >= latestObservedMs(previous);
315329
for (const window of next.windows) {
316330
const existing = byId.get(window.id);
317331
if (existing === undefined || observedAtMs(existing) <= observedAtMs(window)) {
@@ -326,7 +340,9 @@ export function mergeProviderLimits(
326340
(right.durationMinutes ?? Number.MAX_SAFE_INTEGER) ||
327341
left.id.localeCompare(right.id),
328342
);
329-
return { provider: next.provider, plan: next.plan ?? previous?.plan ?? null, windows };
343+
// A delayed older observation must not relabel the plan either.
344+
const plan = next.plan !== null && nextIsNewest ? next.plan : (previous?.plan ?? null);
345+
return { provider: next.provider, plan, windows };
330346
}
331347

332348
function sameWindow(left: UsageLimitWindow, right: UsageLimitWindow): boolean {
@@ -354,12 +370,19 @@ function sameLimits(left: UsageProviderLimits, right: UsageProviderLimits): bool
354370
export class UsageLimitsStore extends Context.Service<
355371
UsageLimitsStore,
356372
{
357-
/** Folds one observation into the store. */
358-
readonly record: (limits: UsageProviderLimits) => Effect.Effect<void>;
373+
/**
374+
* Folds one observation into the store. A `complete` reading replaces the
375+
* provider's window set instead of merging into it.
376+
*/
377+
readonly record: (
378+
limits: UsageProviderLimits,
379+
options?: { readonly complete?: boolean },
380+
) => Effect.Effect<void>;
359381
/**
360382
* Asks providers that can answer on demand (Codex) for a live reading.
361383
* Never fails: a provider that cannot answer leaves its last reading in
362-
* place.
384+
* place. Concurrent callers share one in-flight read rather than each
385+
* launching a CLI.
363386
*/
364387
readonly refresh: Effect.Effect<void>;
365388
readonly read: Effect.Effect<readonly UsageProviderLimits[]>;
@@ -410,11 +433,11 @@ export const make = Effect.gen(function* () {
410433
Effect.catchCause(() => Effect.void),
411434
);
412435

413-
const record: UsageLimitsStore["Service"]["record"] = (limits) =>
436+
const record: UsageLimitsStore["Service"]["record"] = (limits, options) =>
414437
recordSemaphore.withPermits(1)(
415438
Effect.suspend(() => {
416439
const previous = byProvider.get(limits.provider);
417-
const merged = mergeProviderLimits(previous, limits);
440+
const merged = mergeProviderLimits(previous, limits, options);
418441
// Claude repeats the same reading on every request inside a turn; only
419442
// a changed figure is worth a write.
420443
if (previous !== undefined && sameLimits(previous, merged)) return Effect.void;
@@ -423,7 +446,7 @@ export const make = Effect.gen(function* () {
423446
}),
424447
);
425448

426-
const refresh: UsageLimitsStore["Service"]["refresh"] = Effect.gen(function* () {
449+
const refreshOnce = Effect.gen(function* () {
427450
const settings = yield* settingsService.getSettings.pipe(
428451
Effect.catchCause(() => Effect.succeed(null)),
429452
);
@@ -446,7 +469,24 @@ export const make = Effect.gen(function* () {
446469
);
447470
if (response === null) return;
448471
const limits = parseCodexRateLimitsRead(response, observedAt);
449-
if (limits !== null) yield* record(limits);
472+
if (limits !== null) yield* record(limits, { complete: true });
473+
});
474+
475+
// Single-flight: every usage request asks for a refresh, and each one is a
476+
// CLI process. Callers that arrive while one is running wait for it.
477+
let inflightRefresh: Deferred.Deferred<void> | null = null;
478+
const refresh: UsageLimitsStore["Service"]["refresh"] = Effect.suspend(() => {
479+
const existing = inflightRefresh;
480+
if (existing !== null) return Deferred.await(existing);
481+
const created = Deferred.makeUnsafe<void>();
482+
inflightRefresh = created;
483+
return refreshOnce.pipe(
484+
Effect.ensuring(
485+
Effect.sync(() => {
486+
inflightRefresh = null;
487+
}).pipe(Effect.andThen(Deferred.succeed(created, undefined))),
488+
),
489+
);
450490
});
451491

452492
const read: UsageLimitsStore["Service"]["read"] = Effect.sync(() => [...byProvider.values()]);

0 commit comments

Comments
 (0)