Calculate expected costs without PRU limit

Author: RHSplinter

src/App.tsx

@@ -47,7 +47,8 @@ import {
   filterDataByMonth,
   getUserAnalysisData,
   getUserBehaviorData,
-  EXCESS_REQUEST_COST
+  EXCESS_REQUEST_COST,
+  getExpectedExcessCost
 } from "@/lib/utils";
 import { MonthSelector } from "@/components/MonthSelector";
 import { UserSearch } from "@/components/UserSearch";
@@ -351,6 +352,7 @@ type BehaviorScatterChartProps = {
   behaviorData: BehaviorScatterPoint[];
 };
 
+// Isolated the graph due to latency issues. Allows toggling segments without reprocessing data or re-rendering other graphs.
 const BehaviorScatterChart = React.memo(function BehaviorScatterChart({
   behaviorData,
 }: BehaviorScatterChartProps) {
@@ -502,6 +504,7 @@ function App() {
   const [projectedUsersData, setProjectedUsersData] = useState<ProjectedUserData[]>([]);
   const [selectedSearchUser, setSelectedSearchUser] = useState<string | null>(null);
   const [userAnalysisData, setUserAnalysisData] = useState<UserAnalysisData | null>(null);
+  const [expectedExcessCost, setExpectedExcessCost] = useState<number>(0);
   const fileInputRef = useRef<HTMLInputElement>(null);
 
   // Recalculate users exceeding quota when plan selection changes
@@ -515,6 +518,9 @@ function App() {
 
       const projectedDetails = getProjectedUsersExceedingQuotaDetails(data, selectedPlan);
       setProjectedUsersData(projectedDetails);
+
+      const expectedCost = getExpectedExcessCost(data, selectedPlan);
+      setExpectedExcessCost(expectedCost);
 
       // Update user analysis data if a user is selected
       if (selectedSearchUser) {
@@ -633,6 +639,10 @@ function App() {
     // Get the last date available in the filtered CSV for the selected month
     const lastDate = getLastDateFromData(filteredData);
     setLastDateAvailable(lastDate);
+
+    // Get expected excess cost for the selected month
+    const expectedCost = getExpectedExcessCost(filteredData, selectedPlan);
+    setExpectedExcessCost(expectedCost);
 
     // Reset selected power user when month changes
     setSelectedPowerUser(null);
@@ -1367,6 +1377,15 @@ function App() {
                       </span>
                       <ChevronRight className="icon" />
                     </div>
+                    <div
+                      className="flex items-center gap-2"
+                      title="Projected total cost if the monthly quota limit did not exist, based on each user's usage rate and model cost multipliers"
+                    >
+                      <span className="text-sm text-muted-foreground">Expected Cost (no limit):</span>
+                      <span className="text-lg font-bold text-orange-600">
+                        ${expectedExcessCost.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2})}
+                      </span>
+                    </div>
                     {powerUserSummary && (
                       <Sheet>
                         <SheetTrigger asChild>

src/lib/utils.ts

@@ -1,5 +1,6 @@
 import { clsx, type ClassValue } from "clsx"
 import { twMerge } from "tailwind-merge"
+import { defaultServerMainFields } from "vite";
 
 export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs))
@@ -196,8 +197,10 @@ export function getModelUsageSummary(data: CopilotUsageData[]): ModelUsageSummar
 
   data.forEach(item => {
     if (!summary[item.model]) {
-      const multiplier = MODEL_MULTIPLIERS[item.model] || 1;
-      const displayName = DEFAULT_MODELS.includes(item.model) ? 'Default' : item.model;
+      const multiplier = getModelMultiplier(item.model);
+      const displayName = isDefaultModel(item.model) ? 'Default' : item.model;
+
+      console.log(`Processing model: ${item.model}; Multiplier: ${multiplier}; Display Name: ${displayName}`);
 
       summary[item.model] = {
         model: item.model,
@@ -333,26 +336,58 @@ export const PLAN_MONTHLY_LIMITS = {
 } as const;
 
 // Model multipliers based on GitHub documentation (for paid plans)
+// Uses display names as they appear in GitHub Copilot exports.
 export const MODEL_MULTIPLIERS: Record<string, number> = {
-  // Default models (0x multiplier for paid plans)
+  // Current default models (0x multiplier for paid plans)
+  'GPT-4.1': 0,
+  'GPT-4o': 0,
+  'GPT-5 mini': 0,
+  'Raptor mini': 0,
+
+  // OpenAI models
+  'GPT-5.1': 1,
+  'GPT-5.1-Codex': 1,
+  'GPT-5.1-Codex-Mini': 0.33,
+  'GPT-5.1-Codex-Max': 1,
+  'GPT-5.2': 1,
+  'GPT-5.2-Codex': 1,
+  'GPT-5.3-Codex': 1,
+  'GPT-5.4': 1,
+  'GPT-5.4 mini': 0.33,
+
+  // Anthropic models
+  'Claude Haiku 4.5': 0.33,
+  'Claude Sonnet 4': 1,
+  'Claude Sonnet 4.5': 1,
+  'Claude Sonnet 4.6': 1,
+  'Claude Opus 4.5': 3,
+  'Claude Opus 4.6': 3,
+  'Claude Opus 4.6 (fast mode) (preview)': 30,
+
+  // Google models
+  'Gemini 2.5 Pro': 1,
+  'Gemini 3 Flash': 0.33,
+  'Gemini 3 Pro': 1,
+  'Gemini 3.1 Pro': 1,
+
+  // xAI and other models
+  'Grok Code Fast 1': 0.25,
+  'Goldeneye': 1,
+
+  // Backward compatibility for older exports
   'gpt-4o-2024-11-20': 0,
   'gpt-4.1-2025-04-14': 0,
   'gpt-4o': 0,
   'gpt-4.1': 0,
-  // GPT-4.5 models
   'gpt-4.5': 50,
-  // Vision models
   'gpt-4.1-vision': 0,
-  // Claude models
   'claude-sonnet-3.5': 1,
   'claude-sonnet-3.7': 1,
   'claude-sonnet-3.7-thinking': 1.25,
   'claude-sonnet-4': 1,
   'claude-opus-4': 10,
-  // Gemini models
   'gemini-2.0-flash': 0.25,
   'gemini-2.5-pro': 1,
-  // O-series models
   'o1': 10,
   'o3': 1,
   'o3-mini': 0.33,
@@ -363,7 +398,19 @@ export const MODEL_MULTIPLIERS: Record<string, number> = {
 };
 
 // Default models that should be grouped
-export const DEFAULT_MODELS = ['gpt-4o-2024-11-20', 'gpt-4.1-2025-04-14'];
+export const DEFAULT_MODELS = ['GPT-4o', 'GPT-4.1', 'gpt-4o-2024-11-20', 'gpt-4.1-2025-04-14'];
+
+function normalizeModelName(model: string): string {
+  return model.replace(/^Auto:\s*/, '').trim();
+}
+
+function getModelMultiplier(model: string): number {
+  return MODEL_MULTIPLIERS[normalizeModelName(model)] ?? 1;
+}
+
+function isDefaultModel(model: string): boolean {
+  return DEFAULT_MODELS.includes(normalizeModelName(model));
+}
 
 // Cost per excess request (in USD) for premium requests
 export const EXCESS_REQUEST_COST = 0.04; // $0.04 per excess request
@@ -788,6 +835,91 @@ export function getProjectedUsersExceedingQuotaDetails(data: CopilotUsageData[],
   return projectedUsers.sort((a, b) => b.projectedMonthlyTotal - a.projectedMonthlyTotal);
 }
 
+/**
+ * Calculate the total expected excess cost if there were no monthly quota limit.
+ * For each user who has reached the plan limit:
+ * 1. Find the day their cumulative requests hit the limit (budget exhaustion day).
+ * 2. Compute daily average requests per model, excluding the last usage day (to avoid partial-day skew).
+ * 3. Project those requests over the remaining days after the exhaustion day.
+ * 4. Apply each model's cost multiplier and sum the cost at $0.04/PRU.
+ */
+export function getExpectedExcessCost(data: CopilotUsageData[], plan: string = COPILOT_PLANS.BUSINESS): number {
+  if (!data.length) return 0;
+
+  const planLimit = (PLAN_MONTHLY_LIMITS as Record<string, number>)[plan] ?? PLAN_MONTHLY_LIMITS[COPILOT_PLANS.BUSINESS];
+
+  const lastDate = getLastDateFromData(data);
+  if (!lastDate) return 0;
+
+  const lastDateObj = new Date(lastDate);
+  const totalDaysInMonth = new Date(lastDateObj.getFullYear(), lastDateObj.getMonth() + 1, 0).getDate();
+
+  // Group all items by user
+  const userDataMap: Record<string, CopilotUsageData[]> = {};
+  data.forEach(item => {
+    if (!userDataMap[item.user]) userDataMap[item.user] = [];
+    userDataMap[item.user].push(item);
+  });
+
+  let totalExpectedCost = 0;
+
+  Object.values(userDataMap).forEach(userItems => {
+    // Only process users who have reached the plan limit
+    const totalRequests = userItems.reduce((sum, item) => sum + item.requestsUsed, 0);
+    if (totalRequests < planLimit) return;
+
+    // Group by date (YYYY-MM-DD), sorted ascending
+    const byDate: Record<string, CopilotUsageData[]> = {};
+    userItems.forEach(item => {
+      const date = item.timestamp.toISOString().split('T')[0];
+      if (!byDate[date]) byDate[date] = [];
+      byDate[date].push(item);
+    });
+    const sortedDates = Object.keys(byDate).sort();
+
+    // Find the day cumulative requests first reach the plan limit
+    let cumulative = 0;
+    let budgetExhaustionDayOfMonth: number | null = null;
+    for (const date of sortedDates) {
+      const dayTotal = byDate[date].reduce((sum, item) => sum + item.requestsUsed, 0);
+      cumulative += dayTotal;
+      if (cumulative >= planLimit) {
+        budgetExhaustionDayOfMonth = new Date(date).getDate();
+        break;
+      }
+    }
+    if (budgetExhaustionDayOfMonth === null) return;
+
+    const remainingDays = totalDaysInMonth - budgetExhaustionDayOfMonth;
+    if (remainingDays <= 0) return;
+
+    // Compute daily average per model, excluding the last usage day (which may be partial)
+    const lastUsageDate = sortedDates[sortedDates.length - 1];
+    const datesForAverage = sortedDates.filter(d => d !== lastUsageDate);
+    if (datesForAverage.length === 0) return;
+
+    const modelTotals: Record<string, number> = {};
+    datesForAverage.forEach(date => {
+      byDate[date].forEach(item => {
+        modelTotals[item.model] = (modelTotals[item.model] || 0) + item.requestsUsed;
+      });
+    });
+
+    const numDays = datesForAverage.length;
+
+    // Project extra requests per model over remaining days and apply cost multiplier
+    Object.entries(modelTotals).forEach(([model, total]) => {
+      const multiplier = getModelMultiplier(model);
+      if (multiplier === 0) return; // Free models have no cost
+      const dailyAvg = total / numDays;
+      const projectedExtra = dailyAvg * remainingDays;
+      totalExpectedCost += projectedExtra * multiplier * EXCESS_REQUEST_COST;
+    });
+  });
+
+  return totalExpectedCost;
+}
+
 // Re-export month utilities for backward compatibility
 export { getAvailableMonths, filterDataByMonth, getMonthCoverage } from './month-utils';
 export type { MonthOption } from '../types/month';