🤖 fix: consolidate per-model entries when not splitting by mode

- Keep per-model+mode breakdown for 'Split by mode'
- When the toggle is off, aggregate stats across mode/unknown keys so each model appears once

Change-Id: I0e7f6c712dd864862fe185e9fe6b425d96e242b0
Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

src/browser/components/RightSidebar/StatsTab.tsx

@@ -260,7 +260,12 @@ const StatsTabComponent: React.FC<StatsTabProps> = ({ workspaceId }) => {
   }
 
   // Get per-model breakdown (works for both session and last-request)
-  const modelBreakdown: ModelBreakdownEntry[] = (() => {
+  const modelBreakdownData: {
+    /** Per-model+mode entries (no consolidation; keys may be model:mode) */
+    byKey: ModelBreakdownEntry[];
+    /** Consolidated per-model entries (mode ignored) */
+    byModel: ModelBreakdownEntry[];
+  } = (() => {
     if (viewMode === "session") {
       // Session view: aggregate from all completed streams + active
       interface BreakdownEntry {
@@ -335,9 +340,11 @@ const StatsTabComponent: React.FC<StatsTabProps> = ({ workspaceId }) => {
         breakdown[activeKey] = existing;
       }
 
-      // Convert to display format
-      return Object.entries(breakdown).map(([key, stats]) => {
-        const { model, mode } = parseStatsKey(key);
+      const toModelBreakdownEntry = (
+        model: string,
+        stats: BreakdownEntry,
+        mode?: "plan" | "exec"
+      ): ModelBreakdownEntry => {
         const modelTime = Math.max(0, stats.totalDuration - stats.toolExecutionMs);
         const avgTtft = stats.ttftCount > 0 ? stats.ttftSum / stats.ttftCount : null;
         const tokensPerSec = calculateAverageTPS(
@@ -354,6 +361,7 @@ const StatsTabComponent: React.FC<StatsTabProps> = ({ workspaceId }) => {
           stats.responseCount > 0 && stats.totalReasoningTokens > 0
             ? Math.round(stats.totalReasoningTokens / stats.responseCount)
             : null;
+
         return {
           model,
           displayName: getModelDisplayName(model),
@@ -367,68 +375,117 @@ const StatsTabComponent: React.FC<StatsTabProps> = ({ workspaceId }) => {
           tokensPerSec,
           avgTokensPerMsg,
           avgReasoningPerMsg,
-          mode: mode ?? stats.mode,
+          mode,
         };
+      };
+
+      const byKey = Object.entries(breakdown).map(([key, stats]) => {
+        const { model, mode } = parseStatsKey(key);
+        return toModelBreakdownEntry(model, stats, mode ?? stats.mode);
       });
-    } else {
-      // Last Request view: show single model from the last/active request
-      if (!timingStats) return [];
-
-      const elapsed = timingStats.isActive
-        ? now - timingStats.startTime
-        : timingStats.endTime! - timingStats.startTime;
-      const modelTime = Math.max(0, elapsed - timingStats.toolExecutionMs);
-      const ttft =
-        timingStats.firstTokenTime !== null
-          ? timingStats.firstTokenTime - timingStats.startTime
-          : null;
-
-      // For active streams: use live token data
-      // For completed: use stored token counts
-      const outputTokens = timingStats.isActive
-        ? (timingStats.liveTokenCount ?? 0)
-        : (timingStats.outputTokens ?? 0);
-      const reasoningTokens = timingStats.reasoningTokens ?? 0;
-
-      // For active streams: streaming time excludes tool execution
-      // For completed: use stored streamingMs (already excludes tools)
-      const rawStreamingMs = timingStats.isActive
-        ? timingStats.firstTokenTime !== null
-          ? now - timingStats.firstTokenTime
-          : 0
-        : (timingStats.streamingMs ?? 0);
-      const streamingMs = timingStats.isActive
-        ? Math.max(0, rawStreamingMs - timingStats.toolExecutionMs)
-        : rawStreamingMs;
-
-      // Calculate TPS with fallback for old data
-      const tokensPerSec = calculateAverageTPS(
-        streamingMs,
-        modelTime,
-        outputTokens,
-        timingStats.isActive ? (timingStats.liveTPS ?? null) : null
-      );
-
-      return [
-        {
-          model: timingStats.model,
-          displayName: getModelDisplayName(timingStats.model),
-          totalDuration: elapsed,
-          toolExecutionMs: timingStats.toolExecutionMs,
-          modelTime,
-          avgTtft: ttft,
-          responseCount: 1,
-          totalOutputTokens: outputTokens,
-          totalReasoningTokens: reasoningTokens,
-          tokensPerSec,
-          avgTokensPerMsg: outputTokens > 0 ? outputTokens : null,
-          avgReasoningPerMsg: reasoningTokens > 0 ? reasoningTokens : null,
-          mode: timingStats.mode,
-        },
-      ];
+
+      // Consolidate by model when not splitting by mode
+      const consolidated: Record<string, BreakdownEntry> = {};
+      for (const [key, stats] of Object.entries(breakdown)) {
+        const { model } = parseStatsKey(key);
+        const existing = consolidated[model] ?? {
+          totalDuration: 0,
+          toolExecutionMs: 0,
+          streamingMs: 0,
+          responseCount: 0,
+          totalOutputTokens: 0,
+          totalReasoningTokens: 0,
+          ttftSum: 0,
+          ttftCount: 0,
+          liveTPS: null,
+          liveTokenCount: 0,
+        };
+
+        existing.totalDuration += stats.totalDuration;
+        existing.toolExecutionMs += stats.toolExecutionMs;
+        existing.streamingMs += stats.streamingMs;
+        existing.responseCount += stats.responseCount;
+        existing.totalOutputTokens += stats.totalOutputTokens;
+        existing.totalReasoningTokens += stats.totalReasoningTokens;
+        existing.ttftSum += stats.ttftSum;
+        existing.ttftCount += stats.ttftCount;
+
+        // Preserve live data if present (only expected for the active stream)
+        existing.liveTPS = stats.liveTPS ?? existing.liveTPS;
+        existing.liveTokenCount += stats.liveTokenCount;
+
+        consolidated[model] = existing;
+      }
+
+      const byModel = Object.entries(consolidated).map(([model, stats]) => {
+        return toModelBreakdownEntry(model, stats);
+      });
+
+      return { byKey, byModel };
     }
+
+    // Last Request view: show single model from the last/active request
+    if (!timingStats) return { byKey: [], byModel: [] };
+
+    const elapsed = timingStats.isActive
+      ? now - timingStats.startTime
+      : timingStats.endTime! - timingStats.startTime;
+    const modelTime = Math.max(0, elapsed - timingStats.toolExecutionMs);
+    const ttft =
+      timingStats.firstTokenTime !== null
+        ? timingStats.firstTokenTime - timingStats.startTime
+        : null;
+
+    // For active streams: use live token data
+    // For completed: use stored token counts
+    const outputTokens = timingStats.isActive
+      ? (timingStats.liveTokenCount ?? 0)
+      : (timingStats.outputTokens ?? 0);
+    const reasoningTokens = timingStats.reasoningTokens ?? 0;
+
+    // For active streams: streaming time excludes tool execution
+    // For completed: use stored streamingMs (already excludes tools)
+    const rawStreamingMs = timingStats.isActive
+      ? timingStats.firstTokenTime !== null
+        ? now - timingStats.firstTokenTime
+        : 0
+      : (timingStats.streamingMs ?? 0);
+    const streamingMs = timingStats.isActive
+      ? Math.max(0, rawStreamingMs - timingStats.toolExecutionMs)
+      : rawStreamingMs;
+
+    const tokensPerSec = calculateAverageTPS(
+      streamingMs,
+      modelTime,
+      outputTokens,
+      timingStats.isActive ? (timingStats.liveTPS ?? null) : null
+    );
+
+    const entry: ModelBreakdownEntry = {
+      model: timingStats.model,
+      displayName: getModelDisplayName(timingStats.model),
+      totalDuration: elapsed,
+      toolExecutionMs: timingStats.toolExecutionMs,
+      modelTime,
+      avgTtft: ttft,
+      responseCount: 1,
+      totalOutputTokens: outputTokens,
+      totalReasoningTokens: reasoningTokens,
+      tokensPerSec,
+      avgTokensPerMsg: outputTokens > 0 ? outputTokens : null,
+      avgReasoningPerMsg: reasoningTokens > 0 ? reasoningTokens : null,
+      mode: timingStats.mode,
+    };
+
+    return { byKey: [entry], byModel: [entry] };
   })();
 
+  const hasModeData = viewMode === "session" && modelBreakdownData.byKey.some((m) => m.mode);
+  const modelBreakdown =
+    viewMode === "session" && !showModeBreakdown
+      ? modelBreakdownData.byModel
+      : modelBreakdownData.byKey;
+
   return (
     <div className="text-light font-primary text-[13px] leading-relaxed">
       <div data-testid="timing-section" className="mb-6">
@@ -538,7 +595,7 @@ const StatsTabComponent: React.FC<StatsTabProps> = ({ workspaceId }) => {
             <div className="flex items-center justify-between">
               <span className="text-foreground font-medium">By Model</span>
               {/* Only show toggle in session view when we have mode data */}
-              {viewMode === "session" && modelBreakdown.some((m) => m.mode) && (
+              {viewMode === "session" && hasModeData && (
                 <label className="text-muted-light flex cursor-pointer items-center gap-1.5 text-[10px]">
                   <input
                     type="checkbox"