Skip to content

Commit bf84d4b

Browse files
ryoppippiclaude
andauthored
fix(all): collapse per-day rows in monthly/weekly all-agent table (#1148)
* fix(all): merge same-agent rows into one bucket breakdown Monthly and weekly all-agent reports were pushing every daily row into agent_breakdowns instead of merging by agent, so each bucket grew one row per (agent, day) and the table looked like a daily view. Combine rows from the same agent inside AllAccumulator so each bucket renders a single subtotal row per agent. Fixes #1109 * fix(all): sort merged model breakdowns Merged per-agent model breakdowns now follow the same descending cost order used by the aggregate all-agent model breakdowns. This keeps monthly and weekly table output stable after same-agent daily rows are collapsed into one bucket breakdown. --------- Co-authored-by: Claude <[email protected]>
1 parent 4176e95 commit bf84d4b

2 files changed

Lines changed: 177 additions & 8 deletions

File tree

‎rust/crates/ccusage/src/adapter/all/tests.rs‎

Lines changed: 119 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -131,6 +131,125 @@ fn aggregates_daily_agent_rows_by_period() {
131131
assert_eq!(breakdowns[1].agent, "codex");
132132
}
133133

134+
#[test]
135+
fn merges_same_agent_daily_rows_into_one_monthly_breakdown() {
136+
let rows = aggregate_rows(
137+
vec![
138+
AllRow {
139+
period: "2026-01-02".to_string(),
140+
agent: "claude",
141+
models_used: vec!["claude-sonnet-4-20250514".to_string()],
142+
input_tokens: 10,
143+
output_tokens: 5,
144+
cache_creation_tokens: 1,
145+
cache_read_tokens: 2,
146+
total_tokens: 18,
147+
total_cost: 0.01,
148+
metadata: None,
149+
metadata_agents: Some(vec!["claude"]),
150+
agent_breakdowns: None,
151+
model_breakdowns: vec![ModelBreakdown {
152+
model_name: "claude-sonnet-4-20250514".to_string(),
153+
input_tokens: 10,
154+
output_tokens: 5,
155+
cache_creation_tokens: 1,
156+
cache_read_tokens: 2,
157+
cost: 0.01,
158+
..ModelBreakdown::default()
159+
}],
160+
},
161+
AllRow {
162+
period: "2026-01-15".to_string(),
163+
agent: "claude",
164+
models_used: vec!["claude-opus-4-20250514".to_string()],
165+
input_tokens: 20,
166+
output_tokens: 10,
167+
cache_creation_tokens: 2,
168+
cache_read_tokens: 4,
169+
total_tokens: 36,
170+
total_cost: 0.05,
171+
metadata: None,
172+
metadata_agents: Some(vec!["claude"]),
173+
agent_breakdowns: None,
174+
model_breakdowns: vec![ModelBreakdown {
175+
model_name: "claude-opus-4-20250514".to_string(),
176+
input_tokens: 20,
177+
output_tokens: 10,
178+
cache_creation_tokens: 2,
179+
cache_read_tokens: 4,
180+
cost: 0.05,
181+
..ModelBreakdown::default()
182+
}],
183+
},
184+
AllRow {
185+
period: "2026-01-20".to_string(),
186+
agent: "codex",
187+
models_used: vec!["gpt-5".to_string()],
188+
input_tokens: 30,
189+
output_tokens: 15,
190+
cache_creation_tokens: 0,
191+
cache_read_tokens: 6,
192+
total_tokens: 51,
193+
total_cost: 0.02,
194+
metadata: None,
195+
metadata_agents: Some(vec!["codex"]),
196+
agent_breakdowns: None,
197+
model_breakdowns: vec![ModelBreakdown {
198+
model_name: "gpt-5".to_string(),
199+
input_tokens: 30,
200+
output_tokens: 15,
201+
cache_creation_tokens: 0,
202+
cache_read_tokens: 6,
203+
cost: 0.02,
204+
..ModelBreakdown::default()
205+
}],
206+
},
207+
],
208+
AgentReportKind::Monthly,
209+
);
210+
211+
assert_eq!(rows.len(), 1);
212+
assert_eq!(rows[0].period, "2026-01");
213+
assert_eq!(rows[0].input_tokens, 60);
214+
assert_eq!(rows[0].output_tokens, 30);
215+
let breakdowns = rows[0].agent_breakdowns.as_ref().unwrap();
216+
assert_eq!(
217+
breakdowns.len(),
218+
2,
219+
"expected one breakdown row per agent per month, got {breakdowns:#?}"
220+
);
221+
let claude = breakdowns
222+
.iter()
223+
.find(|row| row.agent == "claude")
224+
.expect("claude breakdown present");
225+
assert_eq!(claude.period, "2026-01");
226+
assert_eq!(claude.input_tokens, 30);
227+
assert_eq!(claude.output_tokens, 15);
228+
assert_eq!(claude.cache_creation_tokens, 3);
229+
assert_eq!(claude.cache_read_tokens, 6);
230+
assert_eq!(
231+
claude.models_used,
232+
vec![
233+
"claude-opus-4-20250514".to_string(),
234+
"claude-sonnet-4-20250514".to_string(),
235+
]
236+
);
237+
assert_eq!(claude.model_breakdowns.len(), 2);
238+
assert_eq!(
239+
claude
240+
.model_breakdowns
241+
.iter()
242+
.map(|breakdown| breakdown.model_name.as_str())
243+
.collect::<Vec<_>>(),
244+
vec!["claude-opus-4-20250514", "claude-sonnet-4-20250514",]
245+
);
246+
let codex = breakdowns
247+
.iter()
248+
.find(|row| row.agent == "codex")
249+
.expect("codex breakdown present");
250+
assert_eq!(codex.input_tokens, 30);
251+
}
252+
134253
#[test]
135254
fn renders_all_report_json_with_period_and_agent_metadata() {
136255
let rows = vec![AllRow {

‎rust/crates/ccusage/src/adapter/all/types.rs‎

Lines changed: 58 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ use std::collections::BTreeSet;
22

33
use serde_json::Value;
44

5-
use crate::ModelBreakdown;
5+
use crate::{fast::FxHashMap, ModelBreakdown};
66

77
#[derive(Debug, Clone)]
88
pub(super) struct AllRow {
@@ -55,6 +55,7 @@ pub(super) struct AllAccumulator {
5555
models: BTreeSet<String>,
5656
agents: BTreeSet<&'static str>,
5757
agent_breakdowns: Vec<AllRow>,
58+
agent_indexes: FxHashMap<&'static str, usize>,
5859
}
5960

6061
impl AllAccumulator {
@@ -71,15 +72,25 @@ impl AllAccumulator {
7172
} else if row.agent != "all" {
7273
self.agents.insert(row.agent);
7374
}
74-
self.agent_breakdowns.push(AllRow {
75-
metadata_agents: Some(vec![row.agent]),
76-
agent_breakdowns: None,
77-
..row
78-
});
75+
match self.agent_indexes.get(row.agent).copied() {
76+
Some(index) => merge_agent_breakdown(&mut self.agent_breakdowns[index], row),
77+
None => {
78+
self.agent_indexes
79+
.insert(row.agent, self.agent_breakdowns.len());
80+
self.agent_breakdowns.push(AllRow {
81+
metadata_agents: Some(vec![row.agent]),
82+
agent_breakdowns: None,
83+
..row
84+
});
85+
}
86+
}
7987
}
8088

8189
pub(super) fn into_row(self, period: String) -> AllRow {
8290
let mut agent_breakdowns = self.agent_breakdowns;
91+
for breakdown in &mut agent_breakdowns {
92+
breakdown.period = period.clone();
93+
}
8394
agent_breakdowns.sort_by(|a, b| a.agent.cmp(b.agent));
8495
let mut model_breakdowns = aggregate_model_breakdowns(&agent_breakdowns);
8596
model_breakdowns.sort_by(|a, b| b.cost.total_cmp(&a.cost));
@@ -101,9 +112,48 @@ impl AllAccumulator {
101112
}
102113
}
103114

104-
pub(super) fn aggregate_model_breakdowns(rows: &[AllRow]) -> Vec<ModelBreakdown> {
105-
use crate::fast::FxHashMap;
115+
fn merge_agent_breakdown(target: &mut AllRow, source: AllRow) {
116+
target.input_tokens += source.input_tokens;
117+
target.output_tokens += source.output_tokens;
118+
target.cache_creation_tokens += source.cache_creation_tokens;
119+
target.cache_read_tokens += source.cache_read_tokens;
120+
target.total_tokens += source.total_tokens;
121+
target.total_cost += source.total_cost;
122+
let mut models: BTreeSet<String> = target.models_used.drain(..).collect();
123+
models.extend(source.models_used);
124+
target.models_used = models.into_iter().collect();
125+
target.model_breakdowns =
126+
merge_model_breakdowns(target.model_breakdowns.drain(..), source.model_breakdowns);
127+
}
106128

129+
fn merge_model_breakdowns(
130+
existing: impl IntoIterator<Item = ModelBreakdown>,
131+
additional: impl IntoIterator<Item = ModelBreakdown>,
132+
) -> Vec<ModelBreakdown> {
133+
let mut indexes = FxHashMap::<String, usize>::default();
134+
let mut breakdowns: Vec<ModelBreakdown> = Vec::new();
135+
for item in existing.into_iter().chain(additional) {
136+
let index = *indexes.entry(item.model_name.clone()).or_insert_with(|| {
137+
let i = breakdowns.len();
138+
breakdowns.push(ModelBreakdown {
139+
model_name: item.model_name.clone(),
140+
..ModelBreakdown::default()
141+
});
142+
i
143+
});
144+
let b = &mut breakdowns[index];
145+
b.input_tokens += item.input_tokens;
146+
b.output_tokens += item.output_tokens;
147+
b.cache_creation_tokens += item.cache_creation_tokens;
148+
b.cache_read_tokens += item.cache_read_tokens;
149+
b.extra_total_tokens += item.extra_total_tokens;
150+
b.cost += item.cost;
151+
}
152+
breakdowns.sort_by(|a, b| b.cost.total_cmp(&a.cost));
153+
breakdowns
154+
}
155+
156+
pub(super) fn aggregate_model_breakdowns(rows: &[AllRow]) -> Vec<ModelBreakdown> {
107157
let mut indexes = FxHashMap::<String, usize>::default();
108158
let mut breakdowns: Vec<ModelBreakdown> = Vec::new();
109159
for row in rows {

0 commit comments

Comments
 (0)