Open History to see the last commit
1import {
2 type EnvironmentId,
3 type ModelSelection,
4 type ServerSettings,
5 type ProjectId,
6 resolveProjectProviderInstanceEnabled,
7 type UsageLimitsReport,
8 type ProviderInstanceId,
9 type ProviderConsumeResetCreditInput,
10 type ServerProviderSlashCommand,
11 isProviderAvailable,
12 PROVIDER_DISPLAY_NAMES,
13 type ServerProvider,
14 type ServerProviderResetCredits,
15 type ServerProviderUsageLimits,
16 type ServerProviderUsageWindow,
17 type UsageLimitSourceSnapshots,
18} from "@t3tools/contracts";
19
20import * as DateTime from "effect/DateTime";
21
22const MINUTE = 60_000;
23const HOUR = 60 * MINUTE;
24const DAY = 24 * HOUR;
25
26export function exhaustedUsageWindow(
27 provider: ServerProvider | undefined,
28 now: number,
29 model?: string,
30) {
31 const windows = provider?.usageLimits?.windows ?? [];
32 const exhausted = windows.filter(
33 (window) =>
34 (window.usedPercent ?? 0) >= 100 &&
35 (!window.resetsAt ||
36 !Number.isFinite(Date.parse(window.resetsAt)) ||
37 Date.parse(window.resetsAt) > now),
38 );
39 if (model === undefined) return exhausted[0];
40 switch (provider?.driver) {
41 case "cursor": {
42 const api = exhausted.find((window) => window.id === "apiPercentUsed");
43 const auto = exhausted.find((window) => window.id === "autoPercentUsed");
44 return /^(auto|default|grok|composer)/.test(model) ? auto && api : api;
45 }
46 case "antigravity": {
47 const family = model.match(/^(gemini|claude|gpt)-/)?.[1];
48 return exhausted.find((window) => {
49 const pool = window.id.match(/^(gemini|claude|gpt|3p)-/)?.[1];
50 return (
51 pool === undefined ||
52 family === undefined ||
53 pool === family ||
54 (pool === "3p" && (family === "claude" || family === "gpt"))
55 );
56 });
57 }
58 case "codex": {
59 // Seat-based plans spend credits only past their plan windows, so the credit cap blocks only plans without them.
60 const hasPlanWindows = windows.some(
61 (window) => window.id === "primary" || window.id === "secondary",
62 );
63 return exhausted.find((window) => window.id !== "individual" || !hasPlanWindows);
64 }
65 case "opencode":
66 return exhausted.find(
67 (window) => !window.id.startsWith("go_") || model.startsWith("opencode-go/"),
68 );
69 default:
70 return exhausted[0];
71 }
72}
73
74export function resolveNewThreadModelSelection(input: {
75 readonly defaultSelection: ModelSelection | null;
76 readonly explicitSelection?: ModelSelection | null;
77 readonly fallbackSelection: ModelSelection | null;
78 readonly providers: readonly ServerProvider[];
79 readonly now: number;
80 readonly settings?: ServerSettings;
81 readonly projectId?: ProjectId | null;
82}) {
83 const selection = input.explicitSelection ?? input.defaultSelection;
84 const unchanged = { selection, fallback: null };
85 if (input.explicitSelection || !selection || !input.fallbackSelection) return unchanged;
86 const provider = input.providers.find((entry) => entry.instanceId === selection.instanceId);
87 const window = exhaustedUsageWindow(provider, input.now, selection.model);
88 const fallback = input.providers.find(
89 (entry) => entry.instanceId === input.fallbackSelection?.instanceId,
90 );
91 if (
92 !provider ||
93 !window ||
94 !fallback?.enabled ||
95 !fallback.installed ||
96 fallback.auth.status === "unauthenticated" ||
97 !isProviderAvailable(fallback) ||
98 exhaustedUsageWindow(fallback, input.now, input.fallbackSelection.model) ||
99 (input.settings &&
100 !resolveProjectProviderInstanceEnabled(
101 input.settings,
102 input.projectId ?? null,
103 fallback.instanceId,
104 ))
105 )
106 return unchanged;
107 return {
108 selection: input.fallbackSelection,
109 fallback: { provider, resetsAt: window.resetsAt ?? null },
110 };
111}
112
113export const CHATGPT_USAGE_URL = "https://chatgpt.com/#settings/Usage";
114export const CHATGPT_USAGE_LIMIT_CODE = "subscription_sharing_usage_limit_exceeded";
115/** A ChatGPT Business admin caps plan use in other apps; only the admin can raise it. */
116export const CHATGPT_WORKSPACE_USAGE_LIMIT_CODE =
117 "subscription_sharing_workplace_individual_usage_limit_exceeded";
118/** OpenAI's partner guidelines fix this wording; the user sends it to their admin themselves. */
119export const CHATGPT_WORKSPACE_ADMIN_REQUEST =
120 "I've reached the limit for using my ChatGPT plan in T3 Code. Could you increase our workspace's usage limits so I can continue?\n\nGo to admin.openai.com → Workspace → Usage limits. Thank you!";
121
122export function usesChatGptSharing(provider: ServerProvider | null | undefined): boolean {
123 return provider?.auth.status === "authenticated" && provider.auth.subscriptionSharing === true;
124}
125
126export const CURSOR_USAGE_WINDOWS = [
127 {
128 id: "totalPercentUsed",
129 label: "Overall",
130 description: "All usage on your plan this billing cycle.",
131 },
132 {
133 id: "autoPercentUsed",
134 label: "Cursor Models",
135 description: "Grok, Composer, and Auto use this allowance.",
136 },
137 {
138 id: "apiPercentUsed",
139 label: "Other Models",
140 description: "Usage allowance for third-party models such as Claude, GPT, and Gemini.",
141 },
142] as const;
143
144export function cursorUsageWindowDetails(id: string, pool: LimitPool) {
145 const details = CURSOR_USAGE_WINDOWS.find((window) => window.id === id);
146 return details &&
147 ((pool.windows.length === 1 && id === "totalPercentUsed") || hasDuplicateCursorTotal(pool))
148 ? { ...details, label: null, description: undefined }
149 : details;
150}
151
152function cursorUsageWindowRank(id: string): number {
153 const rank = CURSOR_USAGE_WINDOWS.findIndex((window) => window.id === id);
154 return rank < 0 ? CURSOR_USAGE_WINDOWS.length : rank;
155}
156
157function providersWithLimits(providers: readonly ServerProvider[]): readonly ServerProvider[] {
158 return providers.filter(
159 (provider) =>
160 provider.enabled &&
161 provider.installed &&
162 isProviderAvailable(provider) &&
163 provider.usageLimits !== undefined,
164 );
165}
166
167export type LimitPresentations = ReadonlyMap<
168 EnvironmentId,
169 {
170 readonly entry: { readonly target: { readonly label: string } };
171 readonly serverConfig: {
172 readonly providers: readonly ServerProvider[];
173 readonly usageLimitSources?: UsageLimitSourceSnapshots | undefined;
174 } | null;
175 }
176>;
177
178export function collectExternalUsageLinks(presentations: LimitPresentations) {
179 const links = new Map<
180 string,
181 {
182 readonly label: string;
183 readonly url: string;
184 readonly message: string | undefined;
185 readonly accounts: readonly string[];
186 }
187 >();
188 for (const presentation of presentations.values()) {
189 for (const provider of providersWithLimits(presentation.serverConfig?.providers ?? [])) {
190 const external = provider.usageLimits?.externalUsage;
191 if (external && provider.auth.status === "authenticated") {
192 const account = `${provider.displayName ?? provider.instanceId} on ${presentation.entry.target.label}`;
193 links.set(external.url, {
194 ...external,
195 message: provider.usageLimits?.unavailable?.message,
196 accounts: [...new Set([...(links.get(external.url)?.accounts ?? []), account])],
197 });
198 }
199 }
200 }
201 return [...links.values()];
202}
203
204function accountKey(
205 driver: ServerProvider["driver"],
206 email: string | undefined,
207 limits?: ServerProviderUsageLimits,
208): string | null {
209 const normalizedEmail = email?.trim().toLowerCase();
210 if (normalizedEmail) return `${driver}:${normalizedEmail}`;
211 return limits?.credentialFingerprint
212 ? `${driver}:credential:${limits.credentialFingerprint}`
213 : null;
214}
215
216interface AccountReport {
217 readonly driver: ServerProvider["driver"];
218 readonly email?: string | undefined;
219 readonly workspaceId?: string | undefined;
220 readonly usageLimits?: ServerProviderUsageLimits | undefined;
221}
222
223const nativeReport = (provider: ServerProvider): AccountReport => ({
224 driver: provider.driver,
225 email: provider.auth.email,
226 workspaceId: provider.auth.workspaceId,
227 usageLimits: provider.usageLimits,
228});
229
230// Include every enabled login, even unreadable workspaces.
231function accountKeyResolver(reports: Iterable<AccountReport>) {
232 const workspaces = new Map<string, Set<string>>();
233 for (const report of reports) {
234 const key = accountKey(report.driver, report.email, report.usageLimits);
235 if (key && report.workspaceId) {
236 workspaces.set(key, (workspaces.get(key) ?? new Set()).add(report.workspaceId));
237 }
238 }
239 return (report: AccountReport): string | null => {
240 const key = accountKey(report.driver, report.email, report.usageLimits);
241 if (!key) return null;
242 if (report.workspaceId) return `${key}:${report.workspaceId}`;
243 const known = workspaces.get(key);
244 if (!known) return key;
245 return known.size === 1 ? `${key}:${[...known][0]}` : null;
246 };
247}
248
249const hubAccountName = (account: { readonly id: string }) => account.id.replace(/\.json$/i, "");
250
251export interface LimitAccount {
252 readonly key: string;
253 readonly driver: ServerProvider["driver"];
254 readonly displayName: string | null;
255 readonly email: string | undefined;
256 readonly plan: string | undefined;
257 readonly accentColor: string | undefined;
258 readonly environments: ReadonlyArray<{
259 readonly environmentId: EnvironmentId;
260 readonly label: string;
261 }>;
262 readonly sourceLabel: string | null;
263 readonly redeem: {
264 readonly environmentId: EnvironmentId;
265 readonly input: ProviderConsumeResetCreditInput;
266 } | null;
267 readonly limits: ServerProviderUsageLimits;
268}
269
270export function collectLimitAccounts(presentations: LimitPresentations): readonly LimitAccount[] {
271 const accounts = new Map<string, LimitAccount>();
272 const creditSources = new Map<string, LimitAccount>();
273 const hubRedeems = new Map<string, LimitAccount>();
274 const planSources = new Map<string, LimitAccount>();
275 const merge = (key: string, next: LimitAccount) => {
276 // Prefer hub redemption to clear its routing cooldown too; displayed balance still follows the freshest read.
277 const previousHub = hubRedeems.get(key);
278 if (
279 next.redeem &&
280 "sourceId" in next.redeem.input &&
281 (!previousHub || Date.parse(next.limits.checkedAt) > Date.parse(previousHub.limits.checkedAt))
282 ) {
283 hubRedeems.set(key, next);
284 }
285 const previousCredit = creditSources.get(key);
286 if (
287 next.limits.resetCredits &&
288 (!previousCredit ||
289 Date.parse(next.limits.checkedAt) > Date.parse(previousCredit.limits.checkedAt))
290 ) {
291 creditSources.set(key, next);
292 }
293 const previousPlan = planSources.get(key);
294 if (
295 next.plan &&
296 (!previousPlan ||
297 Date.parse(next.limits.checkedAt) > Date.parse(previousPlan.limits.checkedAt))
298 ) {
299 planSources.set(key, next);
300 }
301 const previous = accounts.get(key);
302 if (!previous) {
303 accounts.set(key, next);
304 return;
305 }
306 const fresher = Date.parse(next.limits.checkedAt) > Date.parse(previous.limits.checkedAt);
307 const environments = [
308 ...previous.environments,
309 ...next.environments.filter(
310 (candidate) =>
311 !previous.environments.some((seen) => seen.environmentId === candidate.environmentId),
312 ),
313 ];
314 const winner = fresher ? next : previous;
315 const creditSource = creditSources.get(key);
316 // A hub e-mail names the account better than the driver's default instance name.
317 const hubEmail = [previous, next].some(
318 (account) => account.environments.length === 0 && account.email,
319 );
320 const displayName = previous.displayName ?? next.displayName;
321 accounts.set(key, {
322 ...previous,
323 displayName:
324 hubEmail &&
325 displayName?.toLowerCase() === PROVIDER_DISPLAY_NAMES[previous.driver]?.toLowerCase()
326 ? null
327 : displayName,
328 plan: planSources.get(key)?.plan ?? previous.plan ?? next.plan,
329 accentColor: previous.accentColor ?? next.accentColor,
330 environments,
331 sourceLabel: environments.length > 0 ? null : (previous.sourceLabel ?? next.sourceLabel),
332 redeem:
333 hubRedeems.get(key)?.redeem ??
334 (creditSource ? creditSource.redeem : (winner.redeem ?? previous.redeem ?? next.redeem)),
335 limits: {
336 ...winner.limits,
337 ...(creditSource?.limits.resetCredits
338 ? { resetCredits: creditSource.limits.resetCredits }
339 : { resetCredits: undefined }),
340 },
341 });
342 };
343 const resolveKey = accountKeyResolver(
344 [...presentations.values()].flatMap((presentation) => [
345 ...(presentation.serverConfig?.providers ?? [])
346 .filter((provider) => provider.enabled)
347 .map(nativeReport),
348 ...(presentation.serverConfig?.usageLimitSources ?? []).flatMap((source) => source.accounts),
349 ]),
350 );
351 for (const [environmentId, presentation] of presentations) {
352 const label = presentation.entry.target.label;
353 for (const provider of providersWithLimits(presentation.serverConfig?.providers ?? [])) {
354 if (!provider.usageLimits || limitsNotice(provider.usageLimits) !== null) continue;
355 merge(resolveKey(nativeReport(provider)) ?? `${environmentId}:${provider.instanceId}`, {
356 key: `${environmentId}:${provider.instanceId}`,
357 driver: provider.driver,
358 displayName: provider.displayName?.trim() || null,
359 email: provider.auth.email,
360 plan: provider.auth.label,
361 accentColor: provider.accentColor,
362 environments: [{ environmentId, label }],
363 sourceLabel: null,
364 redeem: { environmentId, input: { instanceId: provider.instanceId } },
365 limits: provider.usageLimits,
366 });
367 }
368 }
369 const labelEnvironment = presentations.size > 1;
370 for (const [environmentId, presentation] of presentations) {
371 for (const source of presentation.serverConfig?.usageLimitSources ?? []) {
372 const sourceLabel = labelEnvironment
373 ? `${presentation.entry.target.label} · ${source.label}`
374 : source.label;
375 for (const account of source.accounts) {
376 if (limitsNotice(account.usageLimits) !== null) continue;
377 const key = `${source.id}:${account.id}${account.workspaceId ? `:${account.workspaceId}` : ""}`;
378 merge(resolveKey(account) ?? key, {
379 key,
380 driver: account.driver,
381 displayName: account.email ? null : hubAccountName(account),
382 email: account.email,
383 plan: account.plan,
384 accentColor: undefined,
385 environments: [],
386 sourceLabel,
387 redeem: account.usageLimits.resetCredits?.nextCreditId
388 ? {
389 environmentId,
390 input: {
391 sourceId: source.id,
392 accountId: account.id,
393 creditId: account.usageLimits.resetCredits.nextCreditId,
394 },
395 }
396 : null,
397 limits: account.usageLimits,
398 });
399 }
400 }
401 }
402 return [...accounts.values()];
403}
404
405export function collectLimitNotices(presentations: LimitPresentations): readonly string[] {
406 const label = (environmentLabel: string, subject: string) =>
407 presentations.size > 1 ? `${environmentLabel} · ${subject}` : subject;
408 const notices = new Set<string>();
409 for (const presentation of presentations.values()) {
410 const environmentLabel = presentation.entry.target.label;
411 for (const provider of providersWithLimits(presentation.serverConfig?.providers ?? [])) {
412 if (provider.usageLimits?.unavailable?.reason === "unsupported") continue;
413 const notice = provider.usageLimits ? limitsNotice(provider.usageLimits) : null;
414 const name = provider.displayName?.trim() || String(provider.driver);
415 if (notice) notices.add(`${label(environmentLabel, name)}: ${notice}`);
416 }
417 for (const source of presentation.serverConfig?.usageLimitSources ?? []) {
418 if (source.error) {
419 notices.add(`${label(environmentLabel, source.label)}: ${source.error}`);
420 } else if (source.accounts.length === 0) {
421 notices.add(`${label(environmentLabel, source.label)}: No accounts reported.`);
422 }
423 }
424 }
425 return [...notices];
426}
427
428export interface LimitPoolMember {
429 readonly account: LimitAccount;
430 readonly window: ServerProviderUsageWindow;
431 readonly refillPercent: number;
432}
433
434export interface LimitPoolWindow {
435 readonly id: string;
436 readonly kind: ServerProviderUsageWindow["kind"];
437 readonly label: string;
438 readonly members: readonly LimitPoolMember[];
439 readonly columns: ReadonlyArray<
440 LimitPoolMember | { readonly account: LimitAccount; readonly window: null }
441 >;
442 readonly remainingPercent: number;
443 readonly usedPercent: number;
444 readonly pace: LimitPace | null;
445 readonly resets: ReadonlyArray<{
446 readonly member: LimitPoolMember;
447 readonly at: number;
448 readonly restoresPercent: number;
449 }>;
450}
451
452export interface LimitPool {
453 readonly driver: ServerProvider["driver"];
454 readonly accounts: readonly LimitAccount[];
455 readonly windows: readonly LimitPoolWindow[];
456}
457
458function hasDuplicateCursorTotal(pool: LimitPool): boolean {
459 if (pool.windows.length !== 2) return false;
460 const total = pool.windows.find((window) => window.id === "totalPercentUsed");
461 const auto = pool.windows.find((window) => window.id === "autoPercentUsed");
462 return (
463 total !== undefined &&
464 auto !== undefined &&
465 total.members.length === auto.members.length &&
466 total.members.every(({ account, window }) =>
467 account.limits.windows.some(
468 (candidate) =>
469 candidate.id === auto.id &&
470 candidate.kind === auto.kind &&
471 candidate.usedPercent === window.usedPercent &&
472 candidate.resetsAt === window.resetsAt,
473 ),
474 )
475 );
476}
477
478export function displayLimitWindows(pool: LimitPool) {
479 if (pool.driver === "antigravity") {
480 return [...pool.windows].sort(
481 (left, right) =>
482 Number(!left.id.startsWith("gemini-")) - Number(!right.id.startsWith("gemini-")) ||
483 left.id
484 .replace(/-(5h|weekly|quota)$/, "")
485 .localeCompare(right.id.replace(/-(5h|weekly|quota)$/, "")) ||
486 WINDOW_KIND_ORDER[left.kind] - WINDOW_KIND_ORDER[right.kind],
487 );
488 }
489 if (pool.driver !== "cursor") return pool.windows;
490 const hasAuto = pool.windows.some((window) => window.id === "autoPercentUsed");
491 const hasApi = pool.windows.some((window) => window.id === "apiPercentUsed");
492 const hideTotal = (hasAuto && hasApi) || hasDuplicateCursorTotal(pool);
493 return pool.windows
494 .filter((window) => !hideTotal || window.id !== "totalPercentUsed")
495 .sort((left, right) => cursorUsageWindowRank(left.id) - cursorUsageWindowRank(right.id));
496}
497
498const WINDOW_KIND_ORDER: Record<ServerProviderUsageWindow["kind"], number> = {
499 session: 0,
500 weekly: 1,
501 monthly: 2,
502 other: 3,
503};
504
505export function collectLimitPools(
506 accounts: readonly LimitAccount[],
507 now: number,
508): readonly LimitPool[] {
509 const byDriver = new Map<ServerProvider["driver"], LimitAccount[]>();
510 for (const account of accounts) {
511 const list = byDriver.get(account.driver);
512 if (list) list.push(account);
513 else byDriver.set(account.driver, [account]);
514 }
515 return [...byDriver].map(([driver, members]) => {
516 const orderWindow = members
517 .flatMap((account) => account.limits.windows)
518 .sort((left, right) => WINDOW_KIND_ORDER[left.kind] - WINDOW_KIND_ORDER[right.kind])[0];
519 const orderReset = (account: LimitAccount) => {
520 const window = account.limits.windows.find(
521 (window) => orderWindow && poolKey(driver, window) === poolKey(driver, orderWindow),
522 );
523 return (
524 (window ? resetMillis(poolMember(account, window, now).window) : null) ??
525 Number.POSITIVE_INFINITY
526 );
527 };
528 const sorted = [...members].sort(
529 (left, right) =>
530 orderReset(left) - orderReset(right) ||
531 accountSortName(left).localeCompare(accountSortName(right)) ||
532 left.key.localeCompare(right.key),
533 );
534 return { driver, accounts: sorted, windows: poolWindows(sorted, now) };
535 });
536}
537
538function accountSortName(account: LimitAccount): string {
539 return (account.displayName ?? account.email ?? account.key).toLowerCase();
540}
541
542// Codex ids name slots, so pool by kind; other drivers' ids identify distinct allowances.
543function poolKey(driver: ServerProvider["driver"], window: ServerProviderUsageWindow): string {
544 return driver === "codex" ? window.kind : `${window.kind}:${window.id}`;
545}
546
547function poolMember(account: LimitAccount, reported: ServerProviderUsageWindow, now: number) {
548 const spentWeekly =
549 reported.kind === "session"
550 ? account.limits.windows.find(
551 (window) =>
552 window.usedPercent >= 100 &&
553 (account.driver === "claudeAgent"
554 ? window.id === "seven_day"
555 : account.driver === "codex" && window.kind === "weekly"),
556 )
557 : undefined;
558 if (!spentWeekly) return { account, window: reported, refillPercent: reported.usedPercent };
559
560 const weeklyReset = resetMillis(spentWeekly);
561 const sessionReset = resetMillis(reported);
562 const cutoff = Math.max(now, Date.parse(account.limits.checkedAt));
563 let resetsAt: string | undefined;
564 let refillPercent = 0;
565 // A stale or missing clock cannot tell us when blocked quota becomes usable.
566 if (
567 weeklyReset !== null &&
568 sessionReset !== null &&
569 weeklyReset > cutoff &&
570 sessionReset > cutoff
571 ) {
572 if (sessionReset <= weeklyReset) {
573 resetsAt = spentWeekly.resetsAt;
574 refillPercent = 100;
575 } else if (reported.usedPercent >= 100) {
576 resetsAt = reported.resetsAt;
577 refillPercent = 100;
578 } else {
579 resetsAt = spentWeekly.resetsAt;
580 refillPercent = 100 - Math.max(0, Math.min(100, reported.usedPercent));
581 }
582 }
583 return {
584 account,
585 // Suppression is not session spending, so it has no session pace clock.
586 window: { ...reported, usedPercent: 100, resetsAt, windowDurationMins: undefined },
587 refillPercent,
588 };
589}
590
591function poolWindows(accounts: readonly LimitAccount[], now: number): readonly LimitPoolWindow[] {
592 const byKey = new Map<string, LimitPoolMember[]>();
593 for (const account of accounts) {
594 for (const reported of account.limits.windows) {
595 const member = poolMember(account, reported, now);
596 const { window } = member;
597 const pooled = poolKey(account.driver, window);
598 const key = byKey.get(pooled)?.some((member) => member.account === account)
599 ? `${window.kind}:${window.id}`
600 : pooled;
601 const list = byKey.get(key);
602 if (list) list.push(member);
603 else byKey.set(key, [member]);
604 }
605 }
606 const pools = [...byKey].map(([key, members]): LimitPoolWindow => {
607 const memberByAccount = new Map(members.map((member) => [member.account.key, member]));
608 const first = members[0]!.window;
609 const id = members[0]!.account.driver === "codex" ? key : first.id;
610 const usedPercent = members.reduce((sum, m) => sum + m.window.usedPercent, 0) / members.length;
611 // Judge pace only for windows with reset clocks; others add spend without elapsed time.
612 const timed = members.flatMap((m) => {
613 const share = elapsedShare(m.window, now);
614 return share === null ? [] : [{ used: m.window.usedPercent, elapsed: share }];
615 });
616 const timedUsed = timed.reduce((sum, t) => sum + t.used, 0) / timed.length;
617 const meanElapsed =
618 timed.length > 0 ? timed.reduce((sum, t) => sum + t.elapsed, 0) / timed.length : null;
619 const resets = members
620 .flatMap((member) => {
621 const at = resetMillis(member.window);
622 return at === null
623 ? []
624 : [
625 {
626 member,
627 at,
628 restoresPercent: Math.round(member.refillPercent / members.length),
629 },
630 ];
631 })
632 .sort((left, right) => left.at - right.at);
633 return {
634 id,
635 kind: first.kind,
636 label: first.label,
637 members,
638 columns: accounts.map(
639 (account) => memberByAccount.get(account.key) ?? { account, window: null },
640 ),
641 usedPercent: Math.round(usedPercent),
642 remainingPercent: Math.round(100 - usedPercent),
643 pace: meanElapsed === null ? null : paceOfShares(timedUsed, meanElapsed),
644 resets,
645 };
646 });
647 return pools.sort((left, right) => WINDOW_KIND_ORDER[left.kind] - WINDOW_KIND_ORDER[right.kind]);
648}
649
650export function limitsNotice(limits: ServerProviderUsageLimits): string | null {
651 if (limits.unavailable?.reason === "unsupported") {
652 return limits.unavailable.message ?? "This account has no subscription limits.";
653 }
654 if (limits.unavailable?.reason === "probeFailed") {
655 return limits.unavailable.message ?? "Could not read limits.";
656 }
657 return limits.windows.length === 0 ? "No limits reported." : null;
658}
659
660export function remainingPercent(window: ServerProviderUsageWindow): number {
661 return Math.round(100 - Math.max(0, Math.min(100, window.usedPercent)));
662}
663
664function resetMillis(window: ServerProviderUsageWindow): number | null {
665 if (window.resetsAt === undefined) return null;
666 const at = Date.parse(window.resetsAt);
667 return Number.isFinite(at) ? at : null;
668}
669
670export function elapsedShare(window: ServerProviderUsageWindow, now: number): number | null {
671 const resetsAt = resetMillis(window);
672 if (resetsAt === null || window.windowDurationMins === undefined) return null;
673 const length = window.windowDurationMins * MINUTE;
674 if (length <= 0) return null;
675 return Math.max(0, Math.min(1, (length - (resetsAt - now)) / length));
676}
677
678// Bars show quota remaining, so even pace tracks time remaining.
679export function paceRemainingPercent(
680 window: ServerProviderUsageWindow,
681 now: number,
682): number | null {
683 const elapsed = elapsedShare(window, now);
684 return elapsed === null ? null : Math.round((1 - elapsed) * 100);
685}
686
687export type LimitPace = "ahead" | "on" | "under";
688
689export function paceOf(window: ServerProviderUsageWindow, now: number): LimitPace | null {
690 const elapsed = elapsedShare(window, now);
691 return elapsed === null ? null : paceOfShares(window.usedPercent, elapsed);
692}
693
694function paceOfShares(usedPercent: number, elapsed: number): LimitPace {
695 const gap = usedPercent - elapsed * 100;
696 if (gap > 5) return "ahead";
697 if (gap < -5) return "under";
698 return "on";
699}
700
701export function formatDuration(ms: number): string {
702 const remaining = Math.max(0, ms);
703 const days = Math.floor(remaining / DAY);
704 const hours = Math.floor((remaining % DAY) / HOUR);
705 const minutes = Math.floor((remaining % HOUR) / MINUTE);
706 if (days > 0) return `${days}d ${hours}h`;
707 if (hours > 0) return `${hours}h ${minutes}m`;
708 return `${minutes}m`;
709}
710
711/** One redeemable reset as clients offer it; `input` already names the chosen credit. */
712export interface ResetCreditChoice {
713 readonly key: string;
714 readonly summary: string;
715 readonly actionLabel: string;
716 readonly confirmDescription: string;
717 readonly availableCount: number;
718 readonly input: ProviderConsumeResetCreditInput;
719}
720
721export function resetCreditChoices(
722 credits: ServerProviderResetCredits,
723 input: ProviderConsumeResetCreditInput,
724 now: number,
725 compact = false,
726): ReadonlyArray<ResetCreditChoice> {
727 const expiresIn = (at: string | undefined) => (at ? formatDuration(Date.parse(at) - now) : null);
728 if (credits.options && "instanceId" in input) {
729 return credits.options.map((option) => {
730 const expires = expiresIn(option.expiresAt);
731 return {
732 key: option.creditId,
733 summary: `${option.label} · ${option.availableCount} left${expires ? ` · expires in ${expires}` : ""}`,
734 actionLabel: "Use",
735 confirmDescription: `${option.label}: ${option.description} This cannot be undone.`,
736 availableCount: option.availableCount,
737 input: { ...input, creditId: option.creditId },
738 };
739 });
740 }
741 const count = credits.availableCount;
742 const expires = expiresIn(credits.nextExpiresAt);
743 return [
744 {
745 key: "next",
746 summary:
747 count === 0
748 ? "No reset credits banked"
749 : compact
750 ? `${count} banked${expires ? ` · expires in ${expires}` : ""}`
751 : `${count} ${count === 1 ? "reset credit" : "reset credits"} banked${expires ? ` · next expires in ${expires}` : ""}`,
752 actionLabel: "Use reset",
753 confirmDescription:
754 "This redeems one credit on your account and clears the current rate-limit windows. It cannot be undone.",
755 availableCount: count,
756 input,
757 },
758 ];
759}
760
761export function formatResetsIn(window: ServerProviderUsageWindow, now: number): string | null {
762 const resetsAt = resetMillis(window);
763 if (resetsAt === null) return null;
764 if (resetsAt <= now) return "resets now";
765 if (resetsAt - now < MINUTE) return "Resets momentarily";
766 return `resets in ${formatDuration(resetsAt - now)}`;
767}
768
769export const USAGE_LIMITS_COMMAND = {
770 name: "usage-limits",
771 description: "Show this provider's usage limits",
772} satisfies ServerProviderSlashCommand;
773
774export function isUsageLimitsCommand(prompt: string): boolean {
775 return prompt.trim().toLowerCase() === "/usage-limits";
776}
777
778export function hasProviderUsageLimits(
779 driver: ServerProvider["driver"],
780 providers: readonly ServerProvider[],
781 sources: UsageLimitSourceSnapshots,
782): boolean {
783 return (
784 providersWithLimits(providers).some((provider) => provider.driver === driver) ||
785 sources.some(
786 (source) =>
787 source.accounts.some((account) => account.driver === driver) ||
788 (source.error !== undefined && source.accounts.length === 0),
789 )
790 );
791}
792
793export function sameUsageLimitCommandCoverage(
794 previous: UsageLimitSourceSnapshots,
795 next: UsageLimitSourceSnapshots,
796): boolean {
797 const coverage = (sources: UsageLimitSourceSnapshots) =>
798 new Set(
799 sources.flatMap((source) =>
800 source.error !== undefined && source.accounts.length === 0
801 ? ["*"]
802 : source.accounts.map((account) => String(account.driver)),
803 ),
804 );
805 const before = coverage(previous);
806 const after = coverage(next);
807 return before.size === after.size && [...before].every((driver) => after.has(driver));
808}
809
810/** Advertise on workspace catalogs too, which replace the global command list. */
811export function withUsageLimitsCommands(
812 providers: readonly ServerProvider[],
813 sources: UsageLimitSourceSnapshots,
814): ServerProvider[] {
815 const supportedDrivers = new Set([
816 ...providersWithLimits(providers).map((provider) => provider.driver),
817 ...sources.flatMap((source) => source.accounts.map((account) => account.driver)),
818 ]);
819 const unreadableSource = sources.some(
820 (source) => source.error !== undefined && source.accounts.length === 0,
821 );
822 return providers.map((provider) => {
823 if (!unreadableSource && !supportedDrivers.has(provider.driver)) return provider;
824 const commands = (items: readonly ServerProviderSlashCommand[]) => [
825 ...items.filter((command) => command.name !== USAGE_LIMITS_COMMAND.name),
826 USAGE_LIMITS_COMMAND,
827 ];
828 return {
829 ...provider,
830 slashCommands: commands(provider.slashCommands),
831 ...(provider.workspaceSnapshots
832 ? {
833 workspaceSnapshots: provider.workspaceSnapshots.map((snapshot) => ({
834 ...snapshot,
835 slashCommands: commands(snapshot.slashCommands),
836 })),
837 }
838 : {}),
839 };
840 });
841}
842
843export function collectProviderUsageLimits(
844 instanceId: ProviderInstanceId,
845 providers: readonly ServerProvider[],
846 sources: UsageLimitSourceSnapshots,
847 now: number,
848): UsageLimitsReport | null {
849 const selected = providers.find((provider) => provider.instanceId === instanceId);
850 if (!selected || !hasProviderUsageLimits(selected.driver, providers, sources)) return null;
851 const resolveKey = accountKeyResolver([
852 ...providers.filter((provider) => provider.enabled).map(nativeReport),
853 ...sources.flatMap((source) => source.accounts),
854 ]);
855 type NativeSnapshot = { provider: ServerProvider; limits: ServerProviderUsageLimits };
856 const nativeByAccount = new Map<
857 string,
858 { usage: NativeSnapshot; credits: NativeSnapshot | null }
859 >();
860 for (const provider of providersWithLimits(providers)) {
861 if (provider.driver !== selected.driver || !provider.usageLimits) continue;
862 const snapshot = { provider, limits: provider.usageLimits };
863 const key = resolveKey(nativeReport(provider)) ?? `instance:${provider.instanceId}`;
864 const previous = nativeByAccount.get(key);
865 const previousUsable = previous ? limitsNotice(previous.usage.limits) === null : false;
866 const usable = limitsNotice(snapshot.limits) === null;
867 const providerWins =
868 !previous ||
869 (usable && !previousUsable) ||
870 (usable === previousUsable &&
871 Date.parse(snapshot.limits.checkedAt) > Date.parse(previous.usage.limits.checkedAt));
872 const previousCredit = previous?.credits;
873 const credits =
874 snapshot.limits.resetCredits &&
875 (!previousCredit ||
876 Date.parse(snapshot.limits.checkedAt) > Date.parse(previousCredit.limits.checkedAt))
877 ? snapshot
878 : (previousCredit ?? null);
879 nativeByAccount.set(key, {
880 usage: providerWins ? snapshot : previous.usage,
881 credits,
882 });
883 }
884 const native = [...nativeByAccount.values()];
885 const nativeAccountKeys = new Set(
886 native.flatMap(({ usage: { provider, limits } }) => {
887 const key = resolveKey(nativeReport(provider));
888 return key && limits.windows.length && !limits.unavailable ? [key] : [];
889 }),
890 );
891 const accounts: Array<UsageLimitsReport["accounts"][number]> = [];
892 const notices: string[] = [];
893 for (const {
894 usage: { provider, limits },
895 credits,
896 } of native) {
897 const key = resolveKey(nativeReport(provider));
898 const hubCredits = sources
899 .flatMap((source) => source.accounts.map((account) => ({ source, account })))
900 .filter(
901 ({ account }) =>
902 key !== null &&
903 resolveKey(account) === key &&
904 account.usageLimits.resetCredits &&
905 !limitsNotice(account.usageLimits),
906 )
907 .sort(
908 (a, b) =>
909 Date.parse(b.account.usageLimits.checkedAt) - Date.parse(a.account.usageLimits.checkedAt),
910 )[0];
911 const hubCreditId = hubCredits?.account.usageLimits.resetCredits?.nextCreditId;
912 const showHubCredits =
913 hubCredits &&
914 (!credits ||
915 Date.parse(hubCredits.account.usageLimits.checkedAt) >
916 Date.parse(credits.limits.checkedAt));
917 const shownCredits = showHubCredits
918 ? hubCredits.account.usageLimits.resetCredits
919 : credits?.limits.resetCredits;
920 accounts.push({
921 id: provider.instanceId,
922 driver: provider.driver,
923 label: `${provider.displayName?.trim() || String(provider.driver)} [${provider.instanceId}]`,
924 ...(provider.auth.label ? { plan: provider.auth.label } : {}),
925 instanceId: provider.instanceId,
926 resetCreditInput:
927 hubCreditId && hubCredits
928 ? {
929 sourceId: hubCredits.source.id,
930 accountId: hubCredits.account.id,
931 creditId: hubCreditId,
932 }
933 : { instanceId: credits?.provider.instanceId ?? provider.instanceId },
934 ...(provider.displayName ? { displayName: provider.displayName } : {}),
935 ...(provider.accentColor ? { accentColor: provider.accentColor } : {}),
936 ...(provider.auth.email ? { email: provider.auth.email } : {}),
937 limits: shownCredits ? { ...limits, resetCredits: shownCredits } : limits,
938 });
939 }
940 for (const source of sources) {
941 const matching = source.accounts.filter((account) => account.driver === selected.driver);
942 for (const account of matching) {
943 const key = resolveKey(account);
944 if (key && nativeAccountKeys.has(key)) continue;
945 accounts.push({
946 id: `${source.id}:${account.id}`,
947 driver: account.driver,
948 label: `${source.label} · ${hubAccountName(account)}`,
949 sourceLabel: "CLI Proxy",
950 ...(account.usageLimits.resetCredits?.nextCreditId
951 ? {
952 resetCreditInput: {
953 sourceId: source.id,
954 accountId: account.id,
955 creditId: account.usageLimits.resetCredits.nextCreditId,
956 },
957 }
958 : {}),
959 ...(account.plan ? { plan: account.plan } : {}),
960 ...(account.email ? { email: account.email } : {}),
961 limits: account.usageLimits,
962 });
963 }
964 if (source.error && (matching.length > 0 || source.accounts.length === 0)) {
965 notices.push(`${source.label}: ${source.error}`);
966 }
967 }
968 return { createdAt: DateTime.formatIso(DateTime.makeUnsafe(now)), accounts, notices };
969}