@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
tsx 378 lines 12.6 KB
Raw
1 import type {
2 ProviderInstanceId,
3 ServerProvider,
4 ServerProviderUsageLimits,
5 ServerProviderUsageWindow,
6 UsageLimitSourceSnapshots,
7 } from "@t3tools/contracts";
8 import {
9 type LimitPace,
10 type LimitPoolWindow,
11 paceOf,
12 paceRemainingPercent,
13 remainingPercent,
14 } from "@t3tools/shared/usageLimits";
15 import { formatDuration, limitsNotice } from "@t3tools/shared/usageLimitsCopy";
16 import { Link } from "@tanstack/react-router";
17 import { msg, useGT, useLocale, useMessages } from "gt-react";
18 import type { ReactNode } from "react";
19
20 import { usePrimarySettings } from "../../hooks/useSettings";
21 import { useNowMinute } from "../../hooks/useNowMinute";
22 import type { ContextWindowSnapshot } from "@t3tools/client-runtime/state/context-window";
23 import { formatContextWindowTokens } from "../../lib/contextWindow";
24 import { cn } from "../../lib/utils";
25 import { formatUpcomingTimestamp } from "../../timestampFormat";
26 import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
27 import { formatContextWindowCompactionMessage } from "./compaction.logic";
28 import { ThreadDetailsSection } from "./ThreadDetailsSection";
29 import { nextPoolReset, poolSources, resolveThreadDetailsLimits } from "./ThreadDetailsUsage.logic";
30
31 const PACE_LABEL: Record<LimitPace, string> = {
32 ahead: msg("Ahead of pace"),
33 on: msg("On pace"),
34 under: msg("Under pace"),
35 };
36
37 export interface ThreadDetailsUsageInput {
38 readonly providerInstanceId: ProviderInstanceId | null;
39 readonly model: string | null;
40 readonly providers: readonly ServerProvider[];
41 readonly sources: UsageLimitSourceSnapshots;
42 readonly contextWindow: ContextWindowSnapshot | null;
43 }
44
45 type UsageTone = "error" | "warning" | null;
46
47 function limitTone(left: number): UsageTone {
48 if (left <= 10) return "error";
49 if (left <= 20) return "warning";
50 return null;
51 }
52
53 /** The selected provider's limit windows. Each row reads as room left and opens the usage page. */
54 export function ThreadDetailsUsage({
55 providerInstanceId,
56 model,
57 providers,
58 sources,
59 }: Omit<ThreadDetailsUsageInput, "contextWindow">) {
60 const gt = useGT();
61 const nowMinute = useNowMinute();
62 const now = Date.parse(`${nowMinute}:00Z`);
63 const resolved = resolveThreadDetailsLimits(providerInstanceId, model, providers, sources, now);
64 if (!resolved) return null;
65
66 return (
67 <ThreadDetailsSection
68 headingId="thread-details-usage-heading"
69 title={gt("Usage limits")}
70 showHeading={false}
71 >
72 <div className="grid grid-cols-[auto_minmax(3rem,1fr)_auto] gap-x-3 text-xs">
73 {resolved.kind === "pool" ? (
74 resolved.windows.map((window) => <PoolRow key={window.id} window={window} now={now} />)
75 ) : (
76 <InstanceRows limits={resolved.limits} now={now} />
77 )}
78 </div>
79 </ThreadDetailsSection>
80 );
81 }
82
83 function InstanceRows({
84 limits,
85 now,
86 }: {
87 readonly limits: ServerProviderUsageLimits;
88 readonly now: number;
89 }) {
90 const gt = useGT();
91 const m = useMessages();
92 const notice = limitsNotice(limits, m);
93 if (notice) {
94 return (
95 <UsageRow
96 label={gt("Limits", { $context: "usage limits row label" })}
97 fill={null}
98 tone={null}
99 value={gt("Unavailable")}
100 tooltip={<span className="text-foreground">{notice}</span>}
101 opensUsage
102 />
103 );
104 }
105 return limits.windows.map((window) => <LimitRow key={window.id} window={window} now={now} />);
106 }
107
108 /** The thread's context window. The bar fills as context is used; the tick marks auto-compaction. */
109 export function ThreadDetailsContext({ usage }: { readonly usage: ContextWindowSnapshot }) {
110 const maxTokens = usage.maxTokens != null && usage.maxTokens > 0 ? usage.maxTokens : null;
111 const used =
112 maxTokens !== null && usage.usedPercentage !== null
113 ? Math.round(Math.max(0, Math.min(100, usage.usedPercentage)))
114 : null;
115 const threshold = usage.autoCompactThreshold ?? null;
116 const tick =
117 maxTokens !== null && threshold !== null && threshold > 0 && threshold < maxTokens
118 ? (threshold / maxTokens) * 100
119 : null;
120 const gt = useGT();
121 const m = useMessages();
122 const locale = useLocale();
123 const usedTokens = formatContextWindowTokens(usage.usedTokens);
124 return (
125 <ThreadDetailsSection
126 headingId="thread-details-context-heading"
127 title={gt("Context window")}
128 showHeading={false}
129 >
130 <div className="grid grid-cols-[auto_minmax(3rem,1fr)_auto] gap-x-3 text-xs">
131 <UsageRow
132 label={gt("Context", { $context: "context window row label" })}
133 fill={used}
134 tone={used === null ? null : used >= 90 ? "error" : used >= 80 ? "warning" : null}
135 tick={tick}
136 muted
137 value={
138 maxTokens !== null
139 ? `${usedTokens} / ${formatContextWindowTokens(maxTokens)}`
140 : usedTokens
141 }
142 ariaValue={
143 used !== null
144 ? gt("{used}% used", { used })
145 : gt("{usedTokens} tokens used", { usedTokens })
146 }
147 tooltip={
148 <>
149 <span className="text-foreground">
150 {used !== null
151 ? gt("Context: {used}% used", { used })
152 : gt("Context: {usedTokens} tokens used", { usedTokens })}
153 </span>
154 {maxTokens !== null ? (
155 <span className="text-muted-foreground">
156 {gt("{used} of {max} tokens", {
157 used: usage.usedTokens.toLocaleString(locale),
158 max: maxTokens.toLocaleString(locale),
159 })}
160 </span>
161 ) : null}
162 {threshold !== null && threshold > 0 ? (
163 <span className="text-muted-foreground">
164 {formatContextWindowCompactionMessage(threshold, m)}
165 </span>
166 ) : null}
167 </>
168 }
169 />
170 </div>
171 </ThreadDetailsSection>
172 );
173 }
174
175 function LimitRow({
176 window,
177 now,
178 }: {
179 readonly window: ServerProviderUsageWindow;
180 readonly now: number;
181 }) {
182 const gt = useGT();
183 const m = useMessages();
184 const timestampFormat = usePrimarySettings((settings) => settings.timestampFormat);
185 const left = remainingPercent(window);
186 const pace = paceOf(window, now);
187 const timeLeft = paceRemainingPercent(window, now);
188 const resetsAt = window.resetsAt ? Date.parse(window.resetsAt) : Number.NaN;
189 return (
190 <UsageRow
191 label={window.label}
192 fill={left}
193 tone={limitTone(left)}
194 tick={timeLeft}
195 value={`${left}%`}
196 ariaValue={gt("{left}% left", { left })}
197 opensUsage
198 tooltip={
199 <>
200 <span className="text-foreground">
201 {gt("{label}: {left}% left", { label: window.label, left })}
202 </span>
203 {pace && timeLeft !== null ? (
204 <span className="text-muted-foreground">
205 {m(PACE_LABEL[pace])} · {gt("{timeLeft}% of the window left", { timeLeft })}
206 </span>
207 ) : null}
208 {window.resetsAt && resetsAt > now ? (
209 <span className="text-muted-foreground">
210 {gt("Resets in {duration} · {time}", {
211 duration: formatDuration(resetsAt - now, m),
212 time: formatUpcomingTimestamp(window.resetsAt, timestampFormat, now, undefined, m),
213 })}
214 </span>
215 ) : null}
216 </>
217 }
218 />
219 );
220 }
221
222 function PoolRow({ window, now }: { readonly window: LimitPoolWindow; readonly now: number }) {
223 const gt = useGT();
224 const m = useMessages();
225 const timestampFormat = usePrimarySettings((settings) => settings.timestampFormat);
226 const left = window.remainingPercent;
227 const accounts = window.members.length;
228 const from = poolSources(window);
229 const sourceLabels = [...from.hubs, ...(from.signedIn ? [gt("Signed-in accounts")] : [])];
230 const next = nextPoolReset(window, now);
231 const resetsAt = next?.member.window.resetsAt;
232 const reset =
233 next && resetsAt
234 ? {
235 duration: formatDuration(next.at - now, m),
236 time: formatUpcomingTimestamp(resetsAt, timestampFormat, now, undefined, m),
237 }
238 : null;
239 return (
240 <UsageRow
241 label={window.label}
242 fill={left}
243 tone={limitTone(left)}
244 value={`${left}%`}
245 ariaValue={gt("{left}% left", { left })}
246 opensUsage
247 tooltip={
248 <>
249 <span className="text-foreground">
250 {accounts > 1
251 ? gt("{label}: {left}% left across {accounts} accounts", {
252 label: window.label,
253 left,
254 accounts,
255 })
256 : gt("{label}: {left}% left", { label: window.label, left })}
257 </span>
258 {window.pace ? (
259 <span className="text-muted-foreground">{m(PACE_LABEL[window.pace])}</span>
260 ) : null}
261 {next && reset ? (
262 <span className="text-muted-foreground">
263 {accounts > 1
264 ? gt("+{percent}% in {duration} · {time}", {
265 percent: next.restoresPercent,
266 ...reset,
267 })
268 : gt("Resets in {duration} · {time}", reset)}
269 </span>
270 ) : null}
271 {sourceLabels.length > 0 ? (
272 <span className="text-muted-foreground">
273 {gt("From {sources}", { sources: sourceLabels.join(", ") })}
274 </span>
275 ) : null}
276 </>
277 }
278 />
279 );
280 }
281
282 /** One label, hairline, and value row; the whole row opens the details tooltip. With `opensUsage` it links to the usage page. */
283 function UsageRow({
284 label,
285 fill,
286 tone,
287 tick = null,
288 value,
289 ariaValue = value,
290 tooltip,
291 muted = false,
292 opensUsage = false,
293 }: {
294 readonly label: string;
295 /** Bar fill from 0 to 100. Null hides the bar. */
296 readonly fill: number | null;
297 readonly tone: UsageTone;
298 /** A marker on the bar, from 0 to 100. */
299 readonly tick?: number | null;
300 readonly value: string;
301 readonly ariaValue?: string;
302 readonly tooltip: ReactNode;
303 readonly muted?: boolean;
304 readonly opensUsage?: boolean;
305 }) {
306 const gt = useGT();
307 const rowProps = {
308 "aria-label": gt("{label}: {value}", { label, value: ariaValue }),
309 className: cn(
310 "col-span-3 grid h-6 grid-cols-subgrid items-center rounded-lg px-2.5 outline-none hover:bg-black/[0.035] focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring data-popup-open:bg-black/[0.035] dark:hover:bg-white/[0.08] dark:data-popup-open:bg-white/[0.08]",
311 opensUsage
312 ? "group cursor-pointer active:bg-black/[0.06] dark:active:bg-white/[0.12]"
313 : "cursor-default",
314 ),
315 };
316 return (
317 <Tooltip>
318 <TooltipTrigger
319 render={
320 opensUsage ? <Link to="/usage" {...rowProps} /> : <div tabIndex={0} {...rowProps} />
321 }
322 >
323 <span className="max-w-28 truncate text-muted-foreground group-hover:text-foreground">
324 {label}
325 </span>
326 {fill !== null ? (
327 <span className="relative h-[3px] rounded-full bg-muted-foreground/30 dark:bg-muted-foreground/20">
328 {fill > 0 ? (
329 <span
330 className={cn(
331 "absolute inset-y-0 left-0 rounded-full",
332 tone === "error"
333 ? "bg-error"
334 : tone === "warning"
335 ? "bg-warning"
336 : muted
337 ? "bg-muted-foreground"
338 : "bg-foreground/80",
339 )}
340 style={{ width: `max(${fill}%, 6px)` }}
341 />
342 ) : null}
343 {tick !== null ? (
344 <span
345 aria-hidden
346 className="absolute -top-[3px] h-[9px] w-px -translate-x-1/2 bg-foreground/75"
347 style={{ left: `clamp(0.5px, ${tick}%, calc(100% - 0.5px))` }}
348 />
349 ) : null}
350 </span>
351 ) : null}
352 <span
353 className={cn(
354 // Text-only rows span the bar column so they never widen the shared value column.
355 "text-end font-medium tabular-nums",
356 fill === null && "col-span-2",
357 tone === "error"
358 ? "text-error-foreground"
359 : tone === "warning"
360 ? "text-warning-foreground"
361 : fill === null
362 ? "text-muted-foreground"
363 : "text-foreground/80",
364 )}
365 >
366 {value}
367 </span>
368 </TooltipTrigger>
369 {/* Rows sit 8px inside the card; clear its edge instead of overlapping it. */}
370 <TooltipPopup side="left" sideOffset={16}>
371 <div className="flex flex-col gap-0.5">
372 {tooltip}
373 {opensUsage ? <span className="text-muted-foreground">{gt("Open usage")}</span> : null}
374 </div>
375 </TooltipPopup>
376 </Tooltip>
377 );
378 }