"use client"; import { memo, useCallback, useEffect, useId, useRef, useState } from "react"; import { IconInfoCircle } from "@tabler/icons-react"; import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@kandev/ui/tooltip"; import { useTranslation } from "react-i18next"; import { cn } from "@/lib/utils"; import { useSessionContextWindow } from "@/hooks/domains/session/use-session-context-window"; import { useClarificationEscapeGuard } from "@/hooks/use-clarification-escape-guard"; type TokenUsageDisplayProps = { sessionId: string | null; className?: string; }; /** * A context-window report is only trustworthy when we have a positive window * size and usage that does not exceed it. `used > size` is impossible for a * real window, so it means the agent (via the ACP bridge) reported a stale or * wrong `size` (for example, usage and window metadata from different turns). * In that case we hide the indicator instead of showing a confusing >100%. * `used === size` (exactly full) is valid and still renders. */ export function isContextWindowReliable(size: number, used: number): boolean { return size > 0 && used <= size; } function formatNumber(num: number): string { if (num >= 1_000_000) { return `${(num / 1_000_000).toFixed(1)}M`; } if (num >= 1_000) { return `${(num / 1_000).toFixed(1)}K`; } return num.toLocaleString(); } function getCircleColor(efficiency: number): string { if (efficiency >= 90) return "text-yellow-500"; if (efficiency >= 75) return "text-yellow-300"; if (efficiency >= 50) return "text-blue-500"; return "text-blue-300"; } function usePinnableTooltip() { const [open, setOpen] = useState(false); const pinnedRef = useRef(false); const triggerRef = useRef(null); const escapeGuard = useCallback( (event: KeyboardEvent) => event.key === "Escape" && pinnedRef.current, [], ); // Radix dialogs inspect Escape during document capture, before the // document-bubble listener below can close the pinned tooltip. useClarificationEscapeGuard(escapeGuard); useEffect(() => { const closePinnedTooltip = () => { pinnedRef.current = false; setOpen(false); }; const closeOnOutsidePointer = (event: PointerEvent) => { if (!pinnedRef.current || !(event.target instanceof Node)) return; if ( triggerRef.current?.contains(event.target) || (event.target instanceof Element && event.target.closest('[data-slot="tooltip-content"]')) ) { return; } closePinnedTooltip(); }; const closeOnEscape = (event: KeyboardEvent) => { if (event.key !== "Escape" || !pinnedRef.current) return; // Claim the key here: once the pinned tooltip is closed, nothing // further up the tree (e.g. a clarification panel's own // Escape-collapses handler) should also react to the same keypress. event.preventDefault(); event.stopPropagation(); closePinnedTooltip(); }; document.addEventListener("pointerdown", closeOnOutsidePointer); document.addEventListener("keydown", closeOnEscape); return () => { document.removeEventListener("pointerdown", closeOnOutsidePointer); document.removeEventListener("keydown", closeOnEscape); }; }, []); return { open, triggerRef, onOpenChange: (nextOpen: boolean) => { if (!nextOpen && pinnedRef.current) return; setOpen(nextOpen); }, onTriggerClick: () => { pinnedRef.current = !pinnedRef.current; setOpen(pinnedRef.current); }, }; } function ContextWindowRing({ usagePercent }: { usagePercent: number }) { const radius = 10; const strokeWidth = 2.5; const circumference = 2 * Math.PI * radius; const strokeDashoffset = circumference * (1 - usagePercent / 100); return ( ); } function ContextWindowSource({ source }: { source: "acp" | "api" | undefined }) { const { t } = useTranslation(); const helpId = useId(); const [helpOpen, setHelpOpen] = useState(false); const [touchMode, setTouchMode] = useState(false); const pointerDownRef = useRef(false); if (!source) return null; const description = source === "acp" ? "ACP is the active session's effective window, reported by the agent." : "API is the model's advertised maximum from the catalogue and is used when ACP omits the window."; return (
{t("task:source")} {source.toUpperCase()} {description}
); } function ContextCompactionCount({ count }: { count: number }) { const { t } = useTranslation(); const helpId = useId(); const [helpOpen, setHelpOpen] = useState(false); const [touchMode, setTouchMode] = useState(false); const pointerDownRef = useRef(false); return (
{t("common:contextCompactions")}
{count} {t("common:contextCompactionCountHelp")}
); } export const TokenUsageDisplay = memo(function TokenUsageDisplay({ sessionId, className, }: TokenUsageDisplayProps) { const { t } = useTranslation(); const tooltip = usePinnableTooltip(); const contextWindow = useSessionContextWindow(sessionId); if (!contextWindow) return null; const { size, used, source, compactionCount } = contextWindow; // Hide when there's no data yet (size 0) or the report is impossible // (used > size) — see isContextWindowReliable. if (!isContextWindowReliable(size, used)) return null; const usagePercent = (used / size) * 100; const pendingUsage = used === 0; const usagePercentLabel = pendingUsage ? t("task:contextWindowUsagePendingPercent") : `${usagePercent.toFixed(0)}%`; const usageTokenLabel = pendingUsage ? t("task:contextWindowUsagePendingTokens", { size: formatNumber(size) }) : t("task:contextWindowUsedTokens", { used: formatNumber(used), size: formatNumber(size), }); return ( // The UI wrapper defaults this to true; the source control must remain reachable inside.
{t("task:contextWindow")} {usagePercentLabel}
{usageTokenLabel}
{pendingUsage && (

{t("task:contextWindowUsagePendingExplain")}

)}
); });