Skip to content

Commit 92fc162

Browse files
fix(opencode): make session aggregate fallback safe
Avoid adding cumulative session aggregates until all message sources are loaded, so legacy JSON messages suppress matching aggregate rows. Skip aggregate-only fallback rows for bounded reports because cumulative totals cannot be sliced accurately. Preserve message-level legacy and v2 loading. Co-authored-by: amirh-amini <[email protected]>
1 parent 3824f7c commit 92fc162

1 file changed

Lines changed: 142 additions & 28 deletions

File tree

‎rust/adapters/opencode/src/loader.rs‎

Lines changed: 142 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -61,22 +61,25 @@ pub fn load_entries_from_directory(
6161
let window = DateWindow::from_shared(shared, tz.as_ref());
6262
let mut entries = Vec::new();
6363
let mut seen = HashSet::new();
64+
let mut aggregate_entries = Vec::new();
6465
if let Some(db_path) = db_path(opencode_dir) {
65-
for entry in load_entries_from_database(
66+
let database_entries = load_entries_from_database(
6667
&db_path,
6768
tz.as_ref(),
6869
shared.mode,
6970
pricing.as_ref(),
7071
shared,
7172
window,
72-
) {
73+
);
74+
for entry in database_entries.message_entries {
7375
if let Some(id) = entry_id(&entry)
7476
&& !seen.insert(id.to_string())
7577
{
7678
continue;
7779
}
7880
entries.push(entry);
7981
}
82+
aggregate_entries = database_entries.aggregate_entries;
8083
}
8184

8285
let messages_dir = opencode_dir.join("storage").join("message");
@@ -118,6 +121,22 @@ pub fn load_entries_from_directory(
118121
}
119122
entries.push(entry);
120123
}
124+
125+
let message_sessions = entries
126+
.iter()
127+
.map(|entry| entry.session_id.to_string())
128+
.collect::<HashSet<_>>();
129+
for entry in aggregate_entries {
130+
if message_sessions.contains(entry.session_id.as_ref()) {
131+
continue;
132+
}
133+
if let Some(id) = entry_id(&entry)
134+
&& !seen.insert(id.to_string())
135+
{
136+
continue;
137+
}
138+
entries.push(entry);
139+
}
121140
entries.sort_by_key(|entry| entry.timestamp);
122141
Ok(entries)
123142
}
@@ -196,24 +215,30 @@ struct DatabaseLoadContext<'a> {
196215
db_path: &'a Path,
197216
}
198217

218+
#[derive(Default)]
219+
struct DatabaseLoadResult {
220+
message_entries: Vec<LoadedEntry>,
221+
aggregate_entries: Vec<LoadedEntry>,
222+
}
223+
199224
fn load_entries_from_database(
200225
db_path: &Path,
201226
tz: Option<&JiffTimeZone>,
202227
mode: CostMode,
203228
pricing: Option<&PricingMap>,
204229
shared: &SharedArgs,
205230
window: DateWindow,
206-
) -> Vec<LoadedEntry> {
231+
) -> DatabaseLoadResult {
207232
let Ok(connection) =
208233
sqlite::Connection::open_with_flags(db_path, sqlite::OpenFlags::new().with_read_only())
209234
else {
210235
debug_log(
211236
shared,
212237
format!("Failed to open OpenCode database: {}", db_path.display()),
213238
);
214-
return Vec::new();
239+
return DatabaseLoadResult::default();
215240
};
216-
let mut entries = Vec::new();
241+
let mut message_entries = Vec::new();
217242

218243
let mut seen_message_ids = HashSet::new();
219244
let mut message_sessions = HashSet::new();
@@ -278,7 +303,7 @@ fn load_entries_from_database(
278303
) {
279304
let session_key = entry.session_id.to_string();
280305
message_sessions.insert(session_key);
281-
push_unique_entry(&mut entries, &mut seen_message_ids, entry);
306+
push_unique_entry(&mut message_entries, &mut seen_message_ids, entry);
282307
}
283308
}
284309
Ok(sqlite::State::Done) => break,
@@ -359,7 +384,7 @@ fn load_entries_from_database(
359384
let session_key = entry.session_id.to_string();
360385
v2_entries += 1;
361386
message_sessions.insert(session_key);
362-
push_unique_entry(&mut entries, &mut seen_message_ids, entry);
387+
push_unique_entry(&mut message_entries, &mut seen_message_ids, entry);
363388
}
364389
Ok(sqlite::State::Done) => break,
365390
Err(_) => {
@@ -386,31 +411,39 @@ fn load_entries_from_database(
386411
}
387412
}
388413

389-
let mut aggregate_tables = Vec::new();
390-
if table_exists(&connection, "session_v2") {
391-
aggregate_tables.push("session_v2");
392-
}
393-
if has_session_messages && table_exists(&connection, "session") {
394-
aggregate_tables.push("session");
395-
}
396-
let aggregate_context = DatabaseLoadContext {
397-
tz,
398-
mode,
399-
pricing,
400-
window,
401-
shared,
402-
db_path,
403-
};
404-
for table in aggregate_tables {
405-
for entry in load_session_aggregate_entries(&connection, table, &aggregate_context) {
406-
if message_sessions.contains(entry.session_id.as_ref()) {
407-
continue;
414+
let mut aggregate_entries = Vec::new();
415+
if window.is_unbounded() {
416+
// Session aggregates are cumulative and cannot be sliced safely for a
417+
// bounded report, so only unbounded reports may use this fallback.
418+
let mut aggregate_tables = Vec::new();
419+
if table_exists(&connection, "session_v2") {
420+
aggregate_tables.push("session_v2");
421+
}
422+
if has_session_messages && table_exists(&connection, "session") {
423+
aggregate_tables.push("session");
424+
}
425+
let aggregate_context = DatabaseLoadContext {
426+
tz,
427+
mode,
428+
pricing,
429+
window,
430+
shared,
431+
db_path,
432+
};
433+
for table in aggregate_tables {
434+
for entry in load_session_aggregate_entries(&connection, table, &aggregate_context) {
435+
if message_sessions.contains(entry.session_id.as_ref()) {
436+
continue;
437+
}
438+
push_unique_entry(&mut aggregate_entries, &mut seen_message_ids, entry);
408439
}
409-
push_unique_entry(&mut entries, &mut seen_message_ids, entry);
410440
}
411441
}
412442

413-
entries
443+
DatabaseLoadResult {
444+
message_entries,
445+
aggregate_entries,
446+
}
414447
}
415448

416449
fn read_message_file(
@@ -1225,6 +1258,49 @@ mod tests {
12251258
assert_eq!(entries[0].cost, 0.03);
12261259
}
12271260

1261+
#[test]
1262+
fn suppresses_session_aggregate_when_legacy_json_has_message() {
1263+
let fixture = fs_fixture!({
1264+
"storage/message/legacy-json-session/legacy-json-message.json": r#"{"id":"legacy-json-message","sessionID":"legacy-json-session","providerID":"anthropic","modelID":"claude-sonnet-4-20250514","time":{"created":1767312000000},"tokens":{"input":120,"output":60},"cost":0.03}"#,
1265+
});
1266+
let db_path = fixture.path("opencode.db");
1267+
create_db_session_aggregate_table(&db_path, "session_v2");
1268+
insert_db_session_aggregate(
1269+
&db_path,
1270+
"session_v2",
1271+
&SessionAggregateFixture {
1272+
session_id: "legacy-json-session",
1273+
time_created: 1_767_312_000_000,
1274+
model: r#"{"id":"gpt-test","providerID":"openai"}"#,
1275+
cost: 9.99,
1276+
input_tokens: 9_999,
1277+
output_tokens: 9_999,
1278+
cache_read_tokens: 0,
1279+
cache_write_tokens: 0,
1280+
reasoning_tokens: 0,
1281+
},
1282+
);
1283+
1284+
let entries = load_entries_from_directory(
1285+
fixture.root(),
1286+
&SharedArgs {
1287+
mode: CostMode::Display,
1288+
timezone: Some("UTC".to_string()),
1289+
..SharedArgs::default()
1290+
},
1291+
)
1292+
.unwrap();
1293+
1294+
assert_eq!(entries.len(), 1);
1295+
assert_eq!(entries[0].session_id.as_ref(), "legacy-json-session");
1296+
assert_eq!(
1297+
entries[0].data.message.id.as_deref(),
1298+
Some("legacy-json-message")
1299+
);
1300+
assert_eq!(entries[0].data.message.usage.input_tokens, 120);
1301+
assert_eq!(entries[0].cost, 0.03);
1302+
}
1303+
12281304
#[test]
12291305
fn uses_session_v2_aggregate_when_no_message_level_usage_exists() {
12301306
let fixture = fs_fixture!({});
@@ -1268,6 +1344,44 @@ mod tests {
12681344
assert_eq!(entries[0].cost, 0.25);
12691345
}
12701346

1347+
#[test]
1348+
fn excludes_cumulative_session_aggregate_from_bounded_window() {
1349+
let fixture = fs_fixture!({});
1350+
let db_path = fixture.path("opencode.db");
1351+
create_db_session_aggregate_table(&db_path, "session_v2");
1352+
insert_db_session_aggregate(
1353+
&db_path,
1354+
"session_v2",
1355+
&SessionAggregateFixture {
1356+
session_id: "spanning-session",
1357+
time_created: 1_767_312_000_000,
1358+
model: r#"{"id":"gpt-test","providerID":"openai"}"#,
1359+
cost: 0.25,
1360+
input_tokens: 100,
1361+
output_tokens: 50,
1362+
cache_read_tokens: 10,
1363+
cache_write_tokens: 20,
1364+
reasoning_tokens: 5,
1365+
},
1366+
);
1367+
1368+
// The cumulative aggregate includes usage outside this window, so it
1369+
// cannot be attributed safely to the requested date range.
1370+
let entries = load_entries_from_directory(
1371+
fixture.root(),
1372+
&SharedArgs {
1373+
mode: CostMode::Display,
1374+
timezone: Some("UTC".to_string()),
1375+
since: Some("20260102".to_string()),
1376+
until: Some("20260103".to_string()),
1377+
..SharedArgs::default()
1378+
},
1379+
)
1380+
.unwrap();
1381+
1382+
assert!(entries.is_empty());
1383+
}
1384+
12711385
#[test]
12721386
fn uses_current_session_table_as_v2_aggregate_fallback() {
12731387
let fixture = fs_fixture!({});

0 commit comments

Comments
 (0)