Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

usage: Codex effort reads only the session chunks that have Codex threads

yetonef3c4d7b7a73c
diff --git a/internal/usage/codex_effort_shared_test.go b/internal/usage/codex_effort_shared_test.go
index 743d2b925..0c2f22894 100644
--- a/internal/usage/codex_effort_shared_test.go
+++ b/internal/usage/codex_effort_shared_test.go
@@ -191,7 +191,20 @@ func TestCodexModelEffortIsTheWholeLedgers(t *testing.T) {
if len(whole) != 2 {
t.Fatalf("fixture: the whole ledger has %d Codex threads: %+v", len(whole), whole)
}
+ // and only the chunks a Codex thread is known for are read for it:
+ // the Claude Code session's isn't
+ var read []sessions.CallSource
+ visitingActors = func(c *rowChunk) { read = append(read, c.Source) }
+ t.Cleanup(func() { visitingActors = nil })
if got := CodexModelEffort(All); !reflect.DeepEqual(got, whole) {
t.Fatalf("Codex-only ledger:\n got %+v\nwant %+v", got, whole)
}
+ if len(read) == 0 {
+ t.Fatal("no chunk was read for Codex's effort")
+ }
+ for _, src := range read {
+ if src.Path == claude {
+ t.Fatalf("the Claude Code session's chunk was read for Codex's effort: %v", read)
+ }
+ }
}
diff --git a/internal/usage/codex_identity.go b/internal/usage/codex_identity.go
index 88185eee1..558ddd5ac 100644
--- a/internal/usage/codex_identity.go
+++ b/internal/usage/codex_identity.go
@@ -660,7 +660,9 @@ func (groups effortSums) add(row *Row) {
key := modelEffortKey{row.Model, row.Effort}
entry := byModel[key]
if entry == nil {
- entry = &effortTotal{value: sessions.ModelEffort{Model: row.Model, Effort: row.Effort}, priced: true}
+ // the row's strings can be lent (visitActors): what is kept is a copy
+ key = modelEffortKey{strings.Clone(row.Model), strings.Clone(row.Effort)}
+ entry = &effortTotal{value: sessions.ModelEffort{Model: key.model, Effort: key.effort}, priced: true}
byModel[key] = entry
}
entry.priced = entry.priced && row.Priced
diff --git a/internal/usage/request_page.go b/internal/usage/request_page.go
index f07ff990f..fa256e980 100644
--- a/internal/usage/request_page.go
+++ b/internal/usage/request_page.go
@@ -825,7 +825,7 @@ func codexEffortOfIndex(st requestState, p Period, now time.Time) map[string][]s
b := readRequestBlocks(idx, st, p, now, sessions.ReadCallSource)
sums := effortSums{}
ps, next := pairRowsMemo(p, now, b.gateways, b.chunks, b.others, st.codexIdentities, memo)
- ps.visit(func(_ timedRef, r *Row) { sums.add(r) })
+ ps.visitActors(func(r *Row) { sums.add(r) })
b.priced.release()
shared.Lock()
if shared.keep(idx, b.on) {
@@ -1576,6 +1576,28 @@ func (ps *pairedRows) visit(fn func(timedRef, *Row)) {
}
}
+// visitActors is visit of the rows of the chunks a Codex thread is known
+// for some row of (codexActors), the only rows Codex's effort adds up: it
+// decoded every session file's chunk, ~90 MB of what eight Sessions polls
+// allocated, for the few that are Codex's. The rows' strings are lent
+// (lentRows), so fn clones what it keeps.
+func (ps *pairedRows) visitActors(fn func(*Row)) {
+ rows := lentRows()
+ defer rows.release()
+ var r Row
+ for _, c := range ps.all {
+ if slices.ContainsFunc(c.codexActors, func(a string) bool { return a != "" }) {
+ if visitingActors != nil {
+ visitingActors(c)
+ }
+ ps.visitChunk(&rows, c, &r, func(_ timedRef, r *Row) { fn(r) })
+ }
+ }
+}
+
+// visitingActors, in tests, is told each chunk visitActors reads.
+var visitingActors func(*rowChunk)
+
// visitChunk is visit of c's rows alone, read through rows into r.
func (ps *pairedRows) visitChunk(rows *chunkRows, c *rowChunk, r *Row, fn func(timedRef, *Row)) {
open := rows.of(c)