fix(usage): keep reporting-only rows and rounding out of the credit views

Fifth review round, plus a migration renumber — staging took 0310, so the enum
addition is now 0311.

Unbilled rows leaked into every credit-denominated dimension. They carry a user, a
workspace, a workflow and `source = 'workflow'` like any other row, so a BYOK-only
member appeared in Members at zero credits and their runs inflated the event counts
on Workspaces and Sources. Excluded with `HAVING SUM(cost) > 0` rather than a
`category` predicate: `category` is not in
`usage_log_billing_entity_created_at_cost_idx`, so filtering on it would force a
heap fetch on `member` and `source`, the two dimensions that are index-only and the
reason first paint is cheap. `cost` is in that index, and only an unbilled row can
sum to zero.

Ranking BYOK by tokens last round was half a change: `share` still divided cost by
a total cost of zero, so every provider's bar rendered at the same minimum width
and the ranking was invisible. Share is now measured in whatever the list is ranked
by, derived from the same argument so the two cannot disagree.

Series buckets were each rounded to credits independently, so any day under half a
credit rendered as zero — an organization spending a fraction of a credit a day drew
a flat chart beneath a positive headline. They now go through one `apportionCredits`
pass, the same rule the breakdown rows use.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

apps/sim/lib/billing/application/organization-usage/get-organization-usage-summary.ts

@@ -12,7 +12,7 @@ import {
   usageWindowBounds,
 } from '@/lib/billing/core/usage-analytics'
 import { readUsageTimeSeries, readUsageTotals } from '@/lib/billing/core/usage-analytics-queries'
-import { dollarsToCredits } from '@/lib/billing/credits/conversion'
+import { apportionCredits, dollarsToCredits } from '@/lib/billing/credits/conversion'
 
 export interface OrganizationUsageSummaryInput {
   organizationId: string
@@ -73,6 +73,27 @@ export const getOrganizationUsageSummary = defineAuthorizedOrganizationUsageUseC
     ])
 
     const bounds = usageWindowBounds(window)
+    /**
+     * One apportionment across the buckets, not a per-bucket round.
+     *
+     * A day costing less than half a credit rounds to zero on its own, so an
+     * organization spending a fraction of a credit a day drew a flat empty chart under
+     * a positive headline — the reader's conclusion being that the chart is broken.
+     * Largest-remainder distributes the period's rounded total across its buckets, so
+     * the bars sum to the headline and a nonzero day is never drawn as zero.
+     *
+     * Same routine, and the same reasoning, as the breakdown's rows-plus-remainder.
+     */
+    const densified = densifyUsageSeries(seriesRows, window, bucket, input.timezone)
+    const apportioned = apportionCredits(
+      densified.map((point, index) => ({ key: `b:${index}` as const, dollars: point.cost }))
+    )
+    const bucketCredits = densified.map((point, index) => ({
+      timestamp: point.timestamp,
+      credits: apportioned[`b:${index}`] ?? 0,
+      events: point.events,
+    }))
+
     return {
       window: {
         start: bounds.start.toISOString(),
@@ -82,10 +103,9 @@ export const getOrganizationUsageSummary = defineAuthorizedOrganizationUsageUseC
       bucket,
       totals: { credits: dollarsToCredits(totals.cost) },
       previousTotals: previous ? { credits: dollarsToCredits(previous.cost) } : null,
-      // Same timezone the query grouped by, or the series keys cannot match its rows.
-      series: densifyUsageSeries(seriesRows, window, bucket, input.timezone).map((point) => ({
+      series: bucketCredits.map((point) => ({
         timestamp: point.timestamp,
-        credits: dollarsToCredits(point.cost),
+        credits: point.credits,
         events: point.events,
       })),
     }

apps/sim/lib/billing/core/usage-analytics-queries.ts

@@ -143,15 +143,29 @@ export async function readUsageBreakdown(
   if (dimension === 'workflow') conditions.push(isNotNull(usageLog.workflowId))
 
   if (!MODEL_DIMENSIONS.has(dimension)) {
-    return executor
-      .select({
-        key: sql<string | null>`${column}`,
-        cost: sql<string>`COALESCE(SUM(${usageLog.cost}), 0)`,
-        events: sql<number>`COUNT(*)`.mapWith(Number),
-      })
-      .from(usageLog)
-      .where(and(...conditions))
-      .groupBy(column)
+    return (
+      executor
+        .select({
+          key: sql<string | null>`${column}`,
+          cost: sql<string>`COALESCE(SUM(${usageLog.cost}), 0)`,
+          events: sql<number>`COUNT(*)`.mapWith(Number),
+        })
+        .from(usageLog)
+        .where(and(...conditions))
+        .groupBy(column)
+        /**
+         * Drops groups whose every row is reporting-only. Unbilled rows carry a user,
+         * a workspace, a workflow and `source = 'workflow'` like any other, so without
+         * this a BYOK-only member appeared in a credit-denominated list at 0 credits.
+         *
+         * As a `HAVING` on the aggregate rather than a `category` predicate on purpose:
+         * `category` is not in `usage_log_billing_entity_created_at_cost_idx`, so
+         * filtering on it would force a heap fetch on `member` and `source` — the two
+         * dimensions that are index-only today. `cost` is in that index, and only an
+         * unbilled row can sum to zero, since `recordUsage` admits nothing else at zero.
+         */
+        .having(sql`COALESCE(SUM(${usageLog.cost}), 0) > 0`)
+    )
   }
 
   // Already heap-reading `description`, so summing `metadata` costs nothing extra —

apps/sim/lib/billing/core/usage-analytics.test.ts

@@ -434,6 +434,18 @@ describe('foldUsageBreakdown', () => {
     // BYOK ranks by a cost that is zero for every row, so which rows land in the
     // visible slice is effectively arbitrary — dropping the tail's tokens would
     // hide real volume behind an em dash.
+    const byokRows = [
+      { key: 'gpt-4o', cost: '0', events: 1, inputTokens: 100, outputTokens: 50 },
+      { key: 'claude', cost: '0', events: 1, inputTokens: 700, outputTokens: 300 },
+      { key: 'gemini', cost: '0', events: 1, inputTokens: 20, outputTokens: 5 },
+    ]
+    const fold = foldUsageBreakdown(byokRows, 0, labelFor, 3, 'tokens')
+    // Share is measured in the ranking unit, or every BYOK bar renders identical:
+    // a cost-based share is 0/0 for every provider.
+    expect(fold.rows.map((row) => row.share)).toEqual([1000 / 1175, 150 / 1175, 25 / 1175])
+  })
+
+  it('carries the omitted rows tokens, so a zero-cost dimension still adds up', () => {
     const byokRows = [
       { key: 'gpt-4o', cost: '0', events: 1, inputTokens: 100, outputTokens: 50 },
       { key: 'claude', cost: '0', events: 1, inputTokens: 700, outputTokens: 300 },

apps/sim/lib/billing/core/usage-analytics.ts

@@ -469,10 +469,21 @@ export function foldUsageBreakdown(
 
   const visible = ranked.slice(0, limit)
   const hidden = ranked.slice(limit)
-  const share = (cost: number) => (totalCost > 0 ? cost / totalCost : 0)
+  /**
+   * Share is measured in whatever the list is ranked by, because it is what draws the
+   * bar. On BYOK every row costs zero, so a cost-based share made every provider's bar
+   * identical — the minimum width — and the ranking above became invisible.
+   */
+  const shareTotal =
+    rankBy === 'tokens' ? ranked.reduce((sum, row) => sum + row.tokens, 0) : totalCost
+  const share = (row: { cost: number; tokens: number }) =>
+    shareTotal > 0 ? (rankBy === 'tokens' ? row.tokens : row.cost) / shareTotal : 0
 
   return {
-    rows: visible.map(({ tokens: _tokens, ...row }) => ({ ...row, share: share(row.cost) })),
+    rows: visible.map(({ tokens: _tokens, ...row }) => ({
+      ...row,
+      share: share({ cost: row.cost, tokens: _tokens }),
+    })),
     other: {
       cost: hidden.reduce((sum, row) => sum + row.cost, 0),
       events: hidden.reduce((sum, row) => sum + row.events, 0),