diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx index d66d2487ce3..55e738ecda7 100644 --- a/apps/web/src/components/ChatView.tsx +++ b/apps/web/src/components/ChatView.tsx @@ -340,6 +340,7 @@ type ChatViewProps = environmentId: EnvironmentId; threadId: ThreadId; onDiffPanelOpen?: () => void; + onOpenContextTab?: () => void; reserveTitleBarControlInset?: boolean; routeKind: "server"; draftId?: never; @@ -348,6 +349,7 @@ type ChatViewProps = environmentId: EnvironmentId; threadId: ThreadId; onDiffPanelOpen?: () => void; + onOpenContextTab?: () => void; reserveTitleBarControlInset?: boolean; routeKind: "draft"; draftId: DraftId; @@ -1714,7 +1716,9 @@ export default function ChatView(props: ChatViewProps) { replace: true, search: (previous) => { const rest = stripDiffSearchParams(previous); - return diffOpen ? { ...rest, diff: undefined } : { ...rest, diff: "1" }; + return diffOpen + ? { ...rest, diff: undefined, tab: undefined } + : { ...rest, diff: "1", tab: undefined }; }, }); }, [diffOpen, environmentId, isServerThread, navigate, onDiffPanelOpen, threadId]); @@ -3470,8 +3474,8 @@ export default function ChatView(props: ChatViewProps) { search: (previous) => { const rest = stripDiffSearchParams(previous); return filePath - ? { ...rest, diff: "1", diffTurnId: turnId, diffFilePath: filePath } - : { ...rest, diff: "1", diffTurnId: turnId }; + ? { ...rest, diff: "1", diffTurnId: turnId, diffFilePath: filePath, tab: undefined } + : { ...rest, diff: "1", diffTurnId: turnId, tab: undefined }; }, }); }, @@ -3676,6 +3680,7 @@ export default function ChatView(props: ChatViewProps) { scheduleComposerFocus={scheduleComposerFocus} setThreadError={setThreadError} onExpandImage={onExpandTimelineImage} + {...(props.onOpenContextTab ? { onOpenContextTab: props.onOpenContextTab } : {})} /> diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx index b19e1240364..9e201ac1f9d 100644 --- a/apps/web/src/components/chat/ChatComposer.tsx +++ b/apps/web/src/components/chat/ChatComposer.tsx @@ -306,10 +306,16 @@ const ComposerFooterPrimaryActions = memo(function ComposerFooterPrimaryActions( onPreviousPendingQuestion: () => void; onInterrupt: () => void; onImplementPlanInNewThread: () => void; + onOpenContextTab?: () => void; }) { return ( <> - {props.activeContextWindow ? : null} + {props.activeContextWindow && props.onOpenContextTab ? ( + + ) : null} {props.isPreparingWorktree ? ( Preparing worktree... ) : null} @@ -483,6 +489,7 @@ export interface ChatComposerProps { scheduleComposerFocus: () => void; setThreadError: (threadId: ThreadId | null, error: string | null) => void; onExpandImage: (preview: ExpandedImagePreview) => void; + onOpenContextTab?: () => void; } // -------------------------------------------------------------------------- @@ -556,6 +563,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) scheduleComposerFocus, setThreadError, onExpandImage, + onOpenContextTab, } = props; // ------------------------------------------------------------------ @@ -2406,6 +2414,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) onPreviousPendingQuestion={onPreviousActivePendingUserInputQuestion} onInterrupt={handleInterruptPrimaryAction} onImplementPlanInNewThread={handleImplementPlanInNewThreadPrimaryAction} + {...(onOpenContextTab ? { onOpenContextTab } : {})} /> diff --git a/apps/web/src/components/chat/ContextWindowMeter.tsx b/apps/web/src/components/chat/ContextWindowMeter.tsx index 280c262cf23..fdb2bef080b 100644 --- a/apps/web/src/components/chat/ContextWindowMeter.tsx +++ b/apps/web/src/components/chat/ContextWindowMeter.tsx @@ -1,6 +1,5 @@ import { cn } from "~/lib/utils"; import { type ContextWindowSnapshot, formatContextWindowTokens } from "~/lib/contextWindow"; -import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover"; function formatPercentage(value: number | null): string | null { if (value === null || !Number.isFinite(value)) { @@ -12,8 +11,11 @@ function formatPercentage(value: number | null): string | null { return `${Math.round(value)}%`; } -export function ContextWindowMeter(props: { usage: ContextWindowSnapshot }) { - const { usage } = props; +export function ContextWindowMeter(props: { + usage: ContextWindowSnapshot; + onOpenContextTab: () => void; +}) { + const { usage, onOpenContextTab } = props; const usedPercentage = formatPercentage(usage.usedPercentage); const normalizedPercentage = Math.max(0, Math.min(100, usage.usedPercentage ?? 0)); const radius = 9.75; @@ -21,94 +23,54 @@ export function ContextWindowMeter(props: { usage: ContextWindowSnapshot }) { const dashOffset = circumference - (normalizedPercentage / 100) * circumference; return ( - - - - - - {usage.usedPercentage !== null - ? Math.round(usage.usedPercentage) - : formatContextWindowTokens(usage.usedTokens)} - - - - } - /> - -
-
- Context window -
- {usage.maxTokens !== null && usedPercentage ? ( -
- {usedPercentage} - โ‹… - {formatContextWindowTokens(usage.usedTokens)} - / - {formatContextWindowTokens(usage.maxTokens ?? null)} context used -
- ) : ( -
- {formatContextWindowTokens(usage.usedTokens)} tokens used so far -
+
- - + > + {usage.usedPercentage !== null + ? Math.round(usage.usedPercentage) + : formatContextWindowTokens(usage.usedTokens)} + + + ); } diff --git a/apps/web/src/components/chat/SessionContextTab.tsx b/apps/web/src/components/chat/SessionContextTab.tsx new file mode 100644 index 00000000000..403c6960748 --- /dev/null +++ b/apps/web/src/components/chat/SessionContextTab.tsx @@ -0,0 +1,312 @@ +import type { EnvironmentId, ThreadId } from "@t3tools/contracts"; +import { BarChart3, ChevronDown, X } from "lucide-react"; +import { useCallback, useEffect, useMemo, useRef } from "react"; + +import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "~/components/ui/collapsible"; +import { useServerProviders } from "~/rpc/serverState"; +import { useStore } from "~/store"; +import { createThreadSelectorByRef } from "~/storeSelectors"; +import { cn } from "~/lib/utils"; +import type { Thread } from "~/types"; + +import { + estimateSessionContextBreakdown, + type SessionContextBreakdownKey, + type SessionContextBreakdownSegment, +} from "./sessionContextBreakdown"; +import { createSessionContextFormatter } from "./sessionContextFormat"; +import { getSessionContextMetrics, type SessionContextMetrics } from "./sessionContextMetrics"; + +const SEGMENT_COLORS: Record = { + system: "bg-amber-500", + user: "bg-sky-500", + assistant: "bg-emerald-500", + tool: "bg-violet-500", + other: "bg-muted-foreground/40", +}; + +const SEGMENT_LABELS: Record = { + system: "System", + user: "User", + assistant: "Assistant", + tool: "Tool", + other: "Other", +}; + +const scrollPositionByKey = new Map(); + +interface SessionContextTabProps { + environmentId: EnvironmentId; + threadId: ThreadId; + onClose: () => void; +} + +export function SessionContextTab({ environmentId, threadId, onClose }: SessionContextTabProps) { + const threadRef = useMemo(() => ({ environmentId, threadId }), [environmentId, threadId]); + const thread = useStore(useMemo(() => createThreadSelectorByRef(threadRef), [threadRef])); + const providers = useServerProviders(); + + const formatter = useMemo(() => createSessionContextFormatter(), []); + + const metrics = useMemo( + () => (thread ? getSessionContextMetrics(thread, providers) : null), + [thread, providers], + ); + + const breakdown = useMemo( + () => + thread + ? estimateSessionContextBreakdown({ + messages: thread.messages, + activities: thread.activities, + input: metrics?.input ?? null, + }) + : [], + [thread, metrics?.input], + ); + + const scrollKey = `${environmentId}:${threadId}`; + const scrollContainerRef = useRef(null); + const rafHandleRef = useRef(null); + + useEffect(() => { + const node = scrollContainerRef.current; + if (!node) return; + const saved = scrollPositionByKey.get(scrollKey) ?? 0; + node.scrollTop = saved; + }, [scrollKey]); + + useEffect(() => { + return () => { + if (rafHandleRef.current !== null) { + cancelAnimationFrame(rafHandleRef.current); + rafHandleRef.current = null; + } + }; + }, []); + + const handleScroll = useCallback(() => { + if (rafHandleRef.current !== null) return; + rafHandleRef.current = window.requestAnimationFrame(() => { + rafHandleRef.current = null; + const node = scrollContainerRef.current; + if (!node) return; + scrollPositionByKey.set(scrollKey, node.scrollTop); + }); + }, [scrollKey]); + + return ( +
+ +
+ {!thread || !metrics ? ( +
+ Thread is not loaded. +
+ ) : ( +
+ + + +
+ )} +
+
+ ); +} + +function SessionContextTabHeader({ onClose }: { onClose: () => void }) { + return ( +
+
+ + Context Usage +
+ +
+ ); +} + +function StatsGrid({ + metrics, + formatter, +}: { + metrics: SessionContextMetrics; + formatter: ReturnType; +}) { + const rawEntries: Array<{ label: string; value: string }> = [ + { label: "Session", value: metrics.sessionTitle }, + { label: "Messages", value: formatter.number(metrics.messageCount) }, + { label: "Provider", value: metrics.providerLabel }, + { label: "Model", value: metrics.modelLabel }, + { label: "Context Limit", value: formatter.number(metrics.limit) }, + { label: "Total Tokens", value: formatter.number(metrics.total) }, + { label: "Total Processed", value: formatter.number(metrics.totalProcessedTokens) }, + { label: "Usage", value: formatter.percent(metrics.usage) }, + { label: "Input", value: formatter.number(metrics.input) }, + { label: "Output", value: formatter.number(metrics.output) }, + { label: "Reasoning", value: formatter.number(metrics.reasoning) }, + { label: "Cache Read", value: formatter.number(metrics.cacheRead) }, + { label: "User Messages", value: formatter.number(metrics.userMessageCount) }, + { label: "Assistant Messages", value: formatter.number(metrics.assistantMessageCount) }, + { label: "Session Created", value: formatter.time(metrics.sessionCreatedAt) }, + { label: "Last Activity", value: formatter.time(metrics.lastActivityAt) }, + ]; + const entries = rawEntries.filter((entry) => { + const trimmed = entry.value.trim(); + if (trimmed.length === 0 || trimmed === "โ€”") return false; + if (trimmed === "0" || trimmed === "0%") return false; + return true; + }); + + return ( +
+
+ {entries.map((entry) => ( +
+ + {entry.label} + + + {entry.value} + +
+ ))} +
+ {metrics.compactsAutomatically ? ( +

+ Automatically compacts its context when needed. +

+ ) : null} +
+ ); +} + +function BreakdownSection({ + segments, + formatter, +}: { + segments: SessionContextBreakdownSegment[]; + formatter: ReturnType; +}) { + return ( +
+

+ Breakdown +

+ {segments.length === 0 ? ( +

Not enough data to compute a breakdown yet.

+ ) : ( + <> +
+ {segments.map((segment) => ( +
+ ))} +
+
+ {segments.map((segment) => ( +
+ + {SEGMENT_LABELS[segment.key]} + + {segment.percent.toLocaleString()}% + + + {formatter.number(segment.tokens)} + +
+ ))} +
+ + )} +
+ ); +} + +function RawMessagesSection({ + thread, + formatter, +}: { + thread: Thread; + formatter: ReturnType; +}) { + return ( +
+

+ Raw messages +

+ {thread.messages.length === 0 ? ( +

No messages yet.

+ ) : ( +
+ {thread.messages.map((message) => { + const idSuffix = String(message.id).slice(-8); + const json = JSON.stringify( + { ...message, attachments: message.attachments ?? [] }, + null, + 2, + ); + return ( + + + + + {message.role} + + ยท + {idSuffix} + + {formatter.time(message.createdAt)} + + + } + /> + + 
+                    {json}
+
+ + + ); + })} +
+ )} +
+ ); +} diff --git a/apps/web/src/components/chat/sessionContextBreakdown.test.ts b/apps/web/src/components/chat/sessionContextBreakdown.test.ts new file mode 100644 index 00000000000..17e760772d0 --- /dev/null +++ b/apps/web/src/components/chat/sessionContextBreakdown.test.ts @@ -0,0 +1,149 @@ +import { EventId, MessageId, type OrchestrationThreadActivity } from "@t3tools/contracts"; +import { describe, expect, it } from "vitest"; + +import type { ChatMessage } from "~/types"; +import { estimateSessionContextBreakdown } from "./sessionContextBreakdown"; + +let idCounter = 0; +function makeMessage(role: ChatMessage["role"], text: string): ChatMessage { + idCounter += 1; + return { + id: MessageId.make(`msg-${idCounter}`), + role, + text, + createdAt: "2026-01-01T00:00:00Z", + streaming: false, + }; +} + +function makeToolActivity( + kind: "tool.started" | "tool.updated" | "tool.completed", + payload: unknown, + id = `act-${idCounter++}`, +): OrchestrationThreadActivity { + return { + id: EventId.make(id), + tone: "tool", + kind, + summary: kind, + payload, + turnId: null, + createdAt: "2026-01-01T00:00:00Z", + }; +} + +describe("sessionContextBreakdown", () => { + it("estimates token counts from character lengths per role", () => { + const breakdown = estimateSessionContextBreakdown({ + messages: [makeMessage("user", "a".repeat(400)), makeMessage("assistant", "b".repeat(800))], + activities: [], + input: 1000, + }); + const user = breakdown.find((s) => s.key === "user"); + const assistant = breakdown.find((s) => s.key === "assistant"); + expect(user?.tokens).toBe(100); + expect(assistant?.tokens).toBe(200); + }); + + it("includes the system prompt length in the system segment", () => { + const breakdown = estimateSessionContextBreakdown({ + messages: [], + activities: [], + systemPrompt: "x".repeat(40), + input: 1000, + }); + const system = breakdown.find((s) => s.key === "system"); + expect(system?.tokens).toBe(10); + }); + + it("counts tool activities by JSON payload length", () => { + const payload = { name: "edit", args: "y".repeat(396) }; + const activities = [makeToolActivity("tool.started", payload)]; + const expected = Math.ceil(JSON.stringify(payload).length / 4); + const breakdown = estimateSessionContextBreakdown({ + messages: [], + activities, + input: 5000, + }); + expect(breakdown.find((s) => s.key === "tool")?.tokens).toBe(expected); + }); + + it("ignores non-tool activities for the tool segment", () => { + const activities: OrchestrationThreadActivity[] = [ + { + id: EventId.make("act-other"), + tone: "info", + kind: "context-window.updated", + summary: "ctx", + payload: { usedTokens: 100 }, + turnId: null, + createdAt: "2026-01-01T00:00:00Z", + }, + ]; + const breakdown = estimateSessionContextBreakdown({ + messages: [], + activities, + input: 1000, + }); + expect(breakdown.find((s) => s.key === "tool")).toBeUndefined(); + }); + + it("fills remainder into the other segment when estimated tokens fit", () => { + const breakdown = estimateSessionContextBreakdown({ + messages: [makeMessage("user", "hello")], + activities: [], + input: 1000, + }); + const other = breakdown.find((s) => s.key === "other"); + expect(other).toBeDefined(); + const totalTokens = breakdown.reduce((sum, s) => sum + s.tokens, 0); + expect(totalTokens).toBe(1000); + }); + + it("scales segments proportionally when estimated exceeds input", () => { + const breakdown = estimateSessionContextBreakdown({ + messages: [ + makeMessage("user", "a".repeat(10_000)), + makeMessage("assistant", "b".repeat(10_000)), + ], + activities: [], + input: 1000, + }); + const total = breakdown.reduce((sum, s) => sum + s.tokens, 0); + expect(total).toBe(1000); + expect(breakdown.find((s) => s.key === "user")?.tokens ?? 0).toBeGreaterThan(0); + expect(breakdown.find((s) => s.key === "assistant")?.tokens ?? 0).toBeGreaterThan(0); + }); + + it("filters out zero-token segments", () => { + const breakdown = estimateSessionContextBreakdown({ + messages: [makeMessage("user", "hi")], + activities: [], + input: 1000, + }); + expect(breakdown.every((s) => s.tokens > 0)).toBe(true); + expect(breakdown.find((s) => s.key === "assistant")).toBeUndefined(); + }); + + it("returns empty array when there is no data and no input budget", () => { + const breakdown = estimateSessionContextBreakdown({ + messages: [], + activities: [], + input: null, + }); + expect(breakdown).toEqual([]); + }); + + it("emits widths matching the per-segment ratios", () => { + const breakdown = estimateSessionContextBreakdown({ + messages: [makeMessage("user", "a".repeat(400)), makeMessage("assistant", "b".repeat(400))], + activities: [], + input: 1000, + }); + const total = breakdown.reduce((sum, s) => sum + s.tokens, 0); + for (const segment of breakdown) { + const expected = (segment.tokens / total) * 100; + expect(Math.abs(segment.width - expected)).toBeLessThan(1e-6); + } + }); +}); diff --git a/apps/web/src/components/chat/sessionContextBreakdown.ts b/apps/web/src/components/chat/sessionContextBreakdown.ts new file mode 100644 index 00000000000..81262ca12c3 --- /dev/null +++ b/apps/web/src/components/chat/sessionContextBreakdown.ts @@ -0,0 +1,102 @@ +import type { OrchestrationThreadActivity } from "@t3tools/contracts"; + +import type { ChatMessage } from "~/types"; + +export type SessionContextBreakdownKey = "system" | "user" | "assistant" | "tool" | "other"; + +export interface SessionContextBreakdownSegment { + key: SessionContextBreakdownKey; + tokens: number; + width: number; + percent: number; +} + +const CHARS_PER_TOKEN = 4; +const ORDERED_KEYS: SessionContextBreakdownKey[] = ["system", "user", "assistant", "tool", "other"]; + +function charsToTokens(chars: number): number { + if (chars <= 0) return 0; + return Math.ceil(chars / CHARS_PER_TOKEN); +} + +function safeJsonLength(value: unknown): number { + try { + return JSON.stringify(value).length; + } catch { + return 0; + } +} + +export function estimateSessionContextBreakdown(input: { + messages: ReadonlyArray; + activities: ReadonlyArray; + systemPrompt?: string | null; + input: number | null; +}): SessionContextBreakdownSegment[] { + const { messages, activities, systemPrompt, input: inputTokens } = input; + + let systemChars = systemPrompt?.length ?? 0; + let userChars = 0; + let assistantChars = 0; + for (const message of messages) { + const length = message.text?.length ?? 0; + if (message.role === "user") userChars += length; + else if (message.role === "assistant") assistantChars += length; + else if (message.role === "system") systemChars += length; + } + + let toolChars = 0; + for (const activity of activities) { + if ( + activity.kind === "tool.started" || + activity.kind === "tool.updated" || + activity.kind === "tool.completed" + ) { + toolChars += safeJsonLength(activity.payload); + } + } + + const tokens: Record = { + system: charsToTokens(systemChars), + user: charsToTokens(userChars), + assistant: charsToTokens(assistantChars), + tool: charsToTokens(toolChars), + other: 0, + }; + + const estimatedTotal = tokens.system + tokens.user + tokens.assistant + tokens.tool; + + if (inputTokens !== null && inputTokens > 0) { + if (estimatedTotal <= inputTokens) { + tokens.other = inputTokens - estimatedTotal; + } else { + const scale = inputTokens / estimatedTotal; + tokens.system = Math.floor(tokens.system * scale); + tokens.user = Math.floor(tokens.user * scale); + tokens.assistant = Math.floor(tokens.assistant * scale); + tokens.tool = Math.floor(tokens.tool * scale); + const sum = tokens.system + tokens.user + tokens.assistant + tokens.tool; + tokens.other = Math.max(0, inputTokens - sum); + } + } + + const total = ORDERED_KEYS.reduce((sum, key) => sum + tokens[key], 0); + if (total <= 0) { + return []; + } + + const segments: SessionContextBreakdownSegment[] = []; + for (const key of ORDERED_KEYS) { + const count = tokens[key]; + if (count <= 0) continue; + const ratio = count / total; + const percent = Math.round(ratio * 1000) / 10; + segments.push({ + key, + tokens: count, + width: ratio * 100, + percent, + }); + } + return segments; +} diff --git a/apps/web/src/components/chat/sessionContextFormat.ts b/apps/web/src/components/chat/sessionContextFormat.ts new file mode 100644 index 00000000000..706cf4d6aec --- /dev/null +++ b/apps/web/src/components/chat/sessionContextFormat.ts @@ -0,0 +1,39 @@ +export interface SessionContextFormatter { + number(value: number | null): string; + percent(value: number | null): string; + time(value: string | null | undefined): string; +} + +const FALLBACK = "โ€”"; + +export function createSessionContextFormatter( + locale?: string | ReadonlyArray, +): SessionContextFormatter { + const localeArg = locale === undefined ? undefined : (locale as string | string[]); + const numberFormatter = new Intl.NumberFormat(localeArg); + const dateTimeFormatter = new Intl.DateTimeFormat(localeArg, { + dateStyle: "medium", + timeStyle: "short", + }); + const percentFormatter = new Intl.NumberFormat(localeArg, { + minimumFractionDigits: 0, + maximumFractionDigits: 1, + }); + + return { + number(value) { + if (value === null || !Number.isFinite(value)) return FALLBACK; + return numberFormatter.format(value); + }, + percent(value) { + if (value === null || !Number.isFinite(value)) return FALLBACK; + return `${percentFormatter.format(value)}%`; + }, + time(value) { + if (!value) return FALLBACK; + const date = new Date(value); + if (Number.isNaN(date.getTime())) return FALLBACK; + return dateTimeFormatter.format(date); + }, + }; +} diff --git a/apps/web/src/components/chat/sessionContextMetrics.test.ts b/apps/web/src/components/chat/sessionContextMetrics.test.ts new file mode 100644 index 00000000000..9d2a89727b1 --- /dev/null +++ b/apps/web/src/components/chat/sessionContextMetrics.test.ts @@ -0,0 +1,223 @@ +import { + EnvironmentId, + EventId, + MessageId, + ProjectId, + ProviderDriverKind, + ProviderInstanceId, + ThreadId, + type OrchestrationThreadActivity, + type ServerProvider, +} from "@t3tools/contracts"; +import { describe, expect, it } from "vitest"; + +import { + DEFAULT_INTERACTION_MODE, + DEFAULT_RUNTIME_MODE, + type ChatMessage, + type Thread, +} from "~/types"; +import { getSessionContextMetrics } from "./sessionContextMetrics"; + +const environmentId = EnvironmentId.make("env-1"); +const instanceId = ProviderInstanceId.make("codex"); + +function makeMessage(role: ChatMessage["role"], text: string, suffix: string): ChatMessage { + return { + id: MessageId.make(`msg-${suffix}`), + role, + text, + createdAt: `2026-01-01T00:00:${suffix.padStart(2, "0")}Z`, + streaming: false, + }; +} + +function makeContextWindowActivity( + payload: Record, + createdAt = "2026-01-01T00:00:05Z", + id = "activity-1", +): OrchestrationThreadActivity { + return { + id: EventId.make(id), + tone: "info", + kind: "context-window.updated", + summary: "context", + payload, + turnId: null, + createdAt, + }; +} + +function makeThread(overrides: Partial = {}): Thread { + return { + id: ThreadId.make("thread-1"), + environmentId, + codexThreadId: null, + projectId: ProjectId.make("project-1"), + title: "Test Thread", + modelSelection: { + instanceId, + model: "gpt-5-codex", + }, + runtimeMode: DEFAULT_RUNTIME_MODE, + interactionMode: DEFAULT_INTERACTION_MODE, + session: null, + messages: [], + proposedPlans: [], + error: null, + createdAt: "2026-01-01T00:00:00Z", + archivedAt: null, + latestTurn: null, + branch: null, + worktreePath: null, + turnDiffSummaries: [], + activities: [], + ...overrides, + }; +} + +function makeProvider(overrides: Partial = {}): ServerProvider { + return { + instanceId, + driver: ProviderDriverKind.make("codex"), + displayName: "Codex Primary", + enabled: true, + installed: true, + version: null, + status: "ready", + auth: { status: "unknown" }, + checkedAt: "2026-01-01T00:00:00Z", + models: [ + { + slug: "gpt-5-codex", + name: "GPT-5 Codex", + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], + ...overrides, + } as ServerProvider; +} + +describe("sessionContextMetrics", () => { + it("extracts metrics from the latest assistant turn snapshot", () => { + const thread = makeThread({ + messages: [ + makeMessage("user", "hi", "1"), + makeMessage("assistant", "hello", "2"), + makeMessage("user", "ok", "3"), + ], + activities: [ + makeContextWindowActivity( + { + usedTokens: 50, + maxTokens: 1000, + lastInputTokens: 10, + lastOutputTokens: 20, + lastReasoningOutputTokens: 5, + lastCachedInputTokens: 7, + }, + "2026-01-01T00:00:04Z", + "activity-old", + ), + makeContextWindowActivity( + { + usedTokens: 1500, + maxTokens: 10_000, + lastInputTokens: 500, + lastOutputTokens: 300, + lastReasoningOutputTokens: 50, + lastCachedInputTokens: 100, + }, + "2026-01-01T00:00:10Z", + "activity-latest", + ), + ], + }); + + const metrics = getSessionContextMetrics(thread, [makeProvider()]); + + expect(metrics.input).toBe(500); + expect(metrics.output).toBe(300); + expect(metrics.reasoning).toBe(50); + expect(metrics.cacheRead).toBe(100); + expect(metrics.total).toBe(1500); + expect(metrics.limit).toBe(10_000); + expect(metrics.usage).toBe(15); + expect(metrics.lastActivityAt).toBe("2026-01-01T00:00:10Z"); + }); + + it("falls back to cumulative token fields when last* fields are absent", () => { + const thread = makeThread({ + activities: [ + makeContextWindowActivity({ + usedTokens: 50_000, + maxTokens: 200_000, + inputTokens: 30_000, + outputTokens: 15_000, + cachedInputTokens: 4_500, + }), + ], + }); + const metrics = getSessionContextMetrics(thread, [makeProvider()]); + expect(metrics.input).toBe(30_000); + expect(metrics.output).toBe(15_000); + expect(metrics.cacheRead).toBe(4_500); + expect(metrics.total).toBe(50_000); + expect(metrics.usage).toBe(25); + }); + + it("returns null token fields when no snapshot exists", () => { + const thread = makeThread(); + const metrics = getSessionContextMetrics(thread, [makeProvider()]); + expect(metrics.input).toBeNull(); + expect(metrics.output).toBeNull(); + expect(metrics.total).toBeNull(); + expect(metrics.limit).toBeNull(); + expect(metrics.usage).toBeNull(); + }); + + it("falls back to slug when provider/model cannot be resolved", () => { + const thread = makeThread({ + modelSelection: { + instanceId: ProviderInstanceId.make("unknown-instance"), + model: "mystery-model", + }, + }); + const metrics = getSessionContextMetrics(thread, []); + expect(metrics.providerLabel).toBe("unknown-instance"); + expect(metrics.modelLabel).toBe("mystery-model"); + }); + + it("returns null usage when maxTokens is missing", () => { + const thread = makeThread({ + activities: [ + makeContextWindowActivity({ + usedTokens: 1000, + lastInputTokens: 500, + }), + ], + }); + const metrics = getSessionContextMetrics(thread, [makeProvider()]); + expect(metrics.usage).toBeNull(); + expect(metrics.limit).toBeNull(); + }); + + it("splits message counts by role", () => { + const thread = makeThread({ + messages: [ + makeMessage("user", "1", "1"), + makeMessage("assistant", "2", "2"), + makeMessage("user", "3", "3"), + makeMessage("assistant", "4", "4"), + makeMessage("assistant", "5", "5"), + ], + }); + const metrics = getSessionContextMetrics(thread, [makeProvider()]); + expect(metrics.userMessageCount).toBe(2); + expect(metrics.assistantMessageCount).toBe(3); + expect(metrics.messageCount).toBe(5); + }); +}); diff --git a/apps/web/src/components/chat/sessionContextMetrics.ts b/apps/web/src/components/chat/sessionContextMetrics.ts new file mode 100644 index 00000000000..96bea7ddedb --- /dev/null +++ b/apps/web/src/components/chat/sessionContextMetrics.ts @@ -0,0 +1,87 @@ +import type { ServerProvider } from "@t3tools/contracts"; +import { deriveLatestContextWindowSnapshot } from "~/lib/contextWindow"; +import type { Thread } from "~/types"; + +export interface SessionContextMetrics { + sessionTitle: string; + providerLabel: string; + modelLabel: string; + limit: number | null; + input: number | null; + output: number | null; + reasoning: number | null; + cacheRead: number | null; + total: number | null; + totalProcessedTokens: number | null; + compactsAutomatically: boolean; + usage: number | null; + userMessageCount: number; + assistantMessageCount: number; + messageCount: number; + sessionCreatedAt: string; + lastActivityAt: string | null; +} + +export function getSessionContextMetrics( + thread: Thread, + providers: ReadonlyArray, +): SessionContextMetrics { + const snapshot = deriveLatestContextWindowSnapshot(thread.activities); + + const provider = providers.find( + (candidate) => candidate.instanceId === thread.modelSelection.instanceId, + ); + const modelSlug = thread.modelSelection.model; + const model = provider?.models.find((candidate) => candidate.slug === modelSlug); + + const providerLabel = + provider?.displayName?.trim() || provider?.driver || thread.modelSelection.instanceId; + const modelLabel = model?.name?.trim() || modelSlug; + + const input = snapshot?.lastInputTokens ?? snapshot?.inputTokens ?? null; + const output = snapshot?.lastOutputTokens ?? snapshot?.outputTokens ?? null; + const reasoning = snapshot?.lastReasoningOutputTokens ?? snapshot?.reasoningOutputTokens ?? null; + const cacheRead = snapshot?.lastCachedInputTokens ?? snapshot?.cachedInputTokens ?? null; + + const limit = snapshot?.maxTokens ?? null; + const usedTokens = snapshot?.usedTokens ?? null; + const hasAnyToken = input !== null || output !== null || reasoning !== null || cacheRead !== null; + const total = + usedTokens ?? + (hasAnyToken ? (input ?? 0) + (output ?? 0) + (reasoning ?? 0) + (cacheRead ?? 0) : null); + const usage = + limit !== null && limit > 0 && usedTokens !== null && usedTokens > 0 + ? Math.round((usedTokens / limit) * 100) + : null; + + let userMessageCount = 0; + let assistantMessageCount = 0; + for (const message of thread.messages) { + if (message.role === "user") userMessageCount += 1; + else if (message.role === "assistant") assistantMessageCount += 1; + } + + const lastActivity = thread.activities[thread.activities.length - 1]; + const lastMessage = thread.messages[thread.messages.length - 1]; + const lastActivityAt = lastActivity?.createdAt ?? lastMessage?.createdAt ?? null; + + return { + sessionTitle: thread.title, + providerLabel, + modelLabel, + limit, + input, + output, + reasoning, + cacheRead, + total, + totalProcessedTokens: snapshot?.totalProcessedTokens ?? null, + compactsAutomatically: snapshot?.compactsAutomatically ?? false, + usage, + userMessageCount, + assistantMessageCount, + messageCount: thread.messages.length, + sessionCreatedAt: thread.createdAt, + lastActivityAt, + }; +} diff --git a/apps/web/src/diffRouteSearch.ts b/apps/web/src/diffRouteSearch.ts index d9b072f28e1..42065dfc106 100644 --- a/apps/web/src/diffRouteSearch.ts +++ b/apps/web/src/diffRouteSearch.ts @@ -4,6 +4,7 @@ export interface DiffRouteSearch { diff?: "1" | undefined; diffTurnId?: TurnId | undefined; diffFilePath?: string | undefined; + tab?: "context" | undefined; } function isDiffOpenValue(value: unknown): boolean { @@ -20,12 +21,24 @@ function normalizeSearchString(value: unknown): string | undefined { export function stripDiffSearchParams>( params: T, -): Omit { - const { diff: _diff, diffTurnId: _diffTurnId, diffFilePath: _diffFilePath, ...rest } = params; - return rest as Omit; +): Omit { + const { + diff: _diff, + diffTurnId: _diffTurnId, + diffFilePath: _diffFilePath, + tab: _tab, + ...rest + } = params; + return rest as Omit; } export function parseDiffRouteSearch(search: Record): DiffRouteSearch { + const tab = search.tab === "context" ? "context" : undefined; + + if (tab === "context") { + return { tab }; + } + const diff = isDiffOpenValue(search.diff) ? "1" : undefined; const diffTurnIdRaw = diff ? normalizeSearchString(search.diffTurnId) : undefined; const diffTurnId = diffTurnIdRaw ? TurnId.make(diffTurnIdRaw) : undefined; diff --git a/apps/web/src/routes/_chat.$environmentId.$threadId.tsx b/apps/web/src/routes/_chat.$environmentId.$threadId.tsx index 1877fee6f7d..ed262ffcfa0 100644 --- a/apps/web/src/routes/_chat.$environmentId.$threadId.tsx +++ b/apps/web/src/routes/_chat.$environmentId.$threadId.tsx @@ -23,6 +23,7 @@ import { createThreadSelectorByRef } from "../storeSelectors"; import { resolveThreadRouteRef, buildThreadRouteParams } from "../threadRoutes"; import { RightPanelSheet } from "../components/RightPanelSheet"; import { Sidebar, SidebarInset, SidebarProvider, SidebarRail } from "~/components/ui/sidebar"; +import { SessionContextTab } from "../components/chat/SessionContextTab"; const DiffPanel = lazy(() => import("../components/DiffPanel")); const DIFF_INLINE_SIDEBAR_WIDTH_STORAGE_KEY = "chat_diff_sidebar_width"; @@ -30,6 +31,10 @@ const DIFF_INLINE_DEFAULT_WIDTH = "clamp(24rem,34vw,36rem)"; const DIFF_INLINE_SIDEBAR_MIN_WIDTH = 22 * 16; const DIFF_INLINE_SIDEBAR_MAX_WIDTH = 256 * 16; const COMPOSER_COMPACT_MIN_LEFT_CONTROLS_WIDTH_PX = 208; +const CONTEXT_INLINE_SIDEBAR_WIDTH_STORAGE_KEY = "chat_context_sidebar_width"; +const CONTEXT_INLINE_DEFAULT_WIDTH = "clamp(22rem,30vw,32rem)"; +const CONTEXT_INLINE_SIDEBAR_MIN_WIDTH = 20 * 16; +const CONTEXT_INLINE_SIDEBAR_MAX_WIDTH = 256 * 16; const DiffLoadingFallback = (props: { mode: DiffPanelMode }) => { return ( @@ -138,6 +143,56 @@ const DiffPanelInlineSidebar = (props: { ); }; +const ContextPanelInlineSidebar = (props: { + contextOpen: boolean; + onCloseContext: () => void; + onOpenContext: () => void; + environmentId: import("@t3tools/contracts").EnvironmentId; + threadId: import("@t3tools/contracts").ThreadId; +}) => { + const { contextOpen, onCloseContext, onOpenContext, environmentId, threadId } = props; + const onOpenChange = useCallback( + (open: boolean) => { + if (open) { + onOpenContext(); + return; + } + onCloseContext(); + }, + [onCloseContext, onOpenContext], + ); + + return ( + + + {contextOpen ? ( + + ) : null} + + + + ); +}; + function ChatThreadRouteView() { const navigate = useNavigate(); const threadRef = Route.useParams({ @@ -168,6 +223,7 @@ function ChatThreadRouteView() { const serverThreadStarted = threadHasStarted(serverThread); const environmentHasAnyThreads = environmentHasServerThreads || environmentHasDraftThreads; const diffOpen = search.diff === "1"; + const contextOpen = search.tab === "context"; const shouldUseDiffSheet = useMediaQuery(RIGHT_PANEL_INLINE_LAYOUT_MEDIA_QUERY); const currentThreadKey = threadRef ? `${threadRef.environmentId}:${threadRef.threadId}` : null; const [diffPanelMountState, setDiffPanelMountState] = useState(() => ({ @@ -209,10 +265,36 @@ function ChatThreadRouteView() { params: buildThreadRouteParams(threadRef), search: (previous) => { const rest = stripDiffSearchParams(previous); - return { ...rest, diff: "1" }; + return { ...rest, diff: "1", tab: undefined }; }, }); }, [markDiffOpened, navigate, threadRef]); + const closeContext = useCallback(() => { + if (!threadRef) { + return; + } + void navigate({ + to: "/$environmentId/$threadId", + params: buildThreadRouteParams(threadRef), + search: (previous) => { + const rest = stripDiffSearchParams(previous); + return { ...rest, tab: undefined }; + }, + }); + }, [navigate, threadRef]); + const openContext = useCallback(() => { + if (!threadRef) { + return; + } + void navigate({ + to: "/$environmentId/$threadId", + params: buildThreadRouteParams(threadRef), + search: (previous) => { + const rest = stripDiffSearchParams(previous); + return { ...rest, tab: "context" }; + }, + }); + }, [navigate, threadRef]); useEffect(() => { if (!threadRef || !bootstrapComplete) { @@ -245,16 +327,27 @@ function ChatThreadRouteView() { environmentId={threadRef.environmentId} threadId={threadRef.threadId} onDiffPanelOpen={markDiffOpened} - reserveTitleBarControlInset={!diffOpen} + onOpenContextTab={openContext} + reserveTitleBarControlInset={!diffOpen && !contextOpen} routeKind="server" /> - + {contextOpen ? ( + + ) : ( + + )} ); } @@ -266,11 +359,23 @@ function ChatThreadRouteView() { environmentId={threadRef.environmentId} threadId={threadRef.threadId} onDiffPanelOpen={markDiffOpened} + onOpenContextTab={openContext} routeKind="server" /> - - {shouldRenderDiffContent ? : null} + + {contextOpen ? ( + + ) : shouldRenderDiffContent ? ( + + ) : null} ); @@ -279,7 +384,7 @@ function ChatThreadRouteView() { export const Route = createFileRoute("/_chat/$environmentId/$threadId")({ validateSearch: (search) => parseDiffRouteSearch(search), search: { - middlewares: [retainSearchParams(["diff"])], + middlewares: [retainSearchParams(["diff", "tab"])], }, component: ChatThreadRouteView, });