Skip to content

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

usage: CodexModelEffort keeps only the gateway calls a Codex session file's call can be matched to (#2776)

yetone227b864a451c
diff --git a/internal/usage/codex_effort_rows_test.go b/internal/usage/codex_effort_rows_test.go
new file mode 100644
index 000000000..28db18e1c
--- /dev/null
+++ b/internal/usage/codex_effort_rows_test.go
@@ -0,0 +1,92 @@
+package usage
+
+import (
+ "fmt"
+ "path/filepath"
+ "reflect"
+ "runtime"
+ "slices"
+ "testing"
+ "time"
+
+ "github.com/yetone/magpie/internal/sessions"
+)
+
+// threadRows are the rows of a whole ledger that carry a Codex thread.
+func threadRows(l Ledgered) []Row {
+ return slices.DeleteFunc(slices.Clone(l.Rows), func(r Row) bool { return r.codexActor == "" })
+}
+
+// CodexModelEffort's rows are the whole ledger's rows that carry a thread,
+// row for row, though it keeps only the gateway calls a session file's call
+// can be matched to: paired by response id, an ambiguous response id,
+// matched by session and tokens, and unrelated calls around them (#2776).
+func TestCodexEffortRowsAreTheWholeLedgers(t *testing.T) {
+ now, _ := effortFixture(t)
+ root := filepath.Join(sessions.CodexDir(), "sessions", "2026", "09", "30")
+ at := func(d time.Duration) time.Time { return now.Add(-d) }
+ writeCodexCall(t, filepath.Join(root, "rollout-2026-09-30T09-00-00-main-b.jsonl"), "main-b", "main-b", `"cli"`, "resp-b", "m", "high", at(30*time.Minute), 300, 30)
+ writeCodexCall(t, filepath.Join(root, "rollout-2026-09-30T09-10-00-main-c.jsonl"), "main-c", "main-c", `"cli"`, "resp-c", "m2", "low", at(25*time.Minute), 70, 7)
+ writeCodexCall(t, filepath.Join(root, "rollout-2026-09-30T09-20-00-main-d.jsonl"), "main-d", "main-d", `"cli"`, "resp-d", "m", "medium", at(20*time.Minute), 50, 5)
+ writeCodexCall(t, filepath.Join(sessions.CodexDir(), "sessions", "2026", "09", "28", "rollout-2026-09-28T09-00-00-old-e.jsonl"), "old-e", "old-e", `"cli"`, "resp-e", "m", "low", now.Add(-50*time.Hour), 11, 1)
+ // paired by its response id, which the gateway's call alone has
+ Append(Record{Time: at(30 * time.Minute), Agent: "codex", Provider: "openai", Model: "m", Effort: "xhigh", Input: 300, Output: 30, Status: 200, ResponseID: "resp-b", Session: "main-b"})
+ // two gateway calls with one response id: neither is paired
+ Append(Record{Time: at(25 * time.Minute), Agent: "codex", Provider: "openai", Model: "m2", Input: 70, Output: 7, Status: 200, ResponseID: "resp-c"})
+ Append(Record{Time: at(25 * time.Minute), Agent: "codex", Provider: "openai", Model: "m2", Input: 70, Output: 7, Status: 200, ResponseID: "resp-c"})
+ // matched by session and tokens: the session file's call is the gateway's
+ Append(Record{Time: at(20 * time.Minute), Agent: "codex", Provider: "openai", Model: "m", Input: 50, Output: 5, Status: 200, NativeSession: "main-d"})
+ // paired two days ago
+ Append(Record{Time: now.Add(-50 * time.Hour), Agent: "codex", Provider: "openai", Model: "m", Input: 11, Output: 1, Status: 200, ResponseID: "resp-e", Session: "old-e"})
+ for i := range 40 {
+ Append(Record{Time: at(time.Duration(i) * time.Minute), Agent: "claude-code", Provider: "anthropic", Model: "claude-opus-5-5", Input: 40 + i, Output: 4, Status: 200, RequestID: fmt.Sprintf("req_%d", i), Session: "sess1"})
+ Append(Record{Time: at(time.Duration(i) * time.Minute), Agent: "codex", Provider: "openai", Model: "m", Input: 9, Output: 9, Status: 200, ResponseID: fmt.Sprintf("resp-other-%d", i), Session: "elsewhere"})
+ }
+ for _, p := range []Period{All, Today, Week} {
+ for name, reader := range map[string]func(time.Time) []sessions.Call{"codex": codexCalls, "every agent": sessions.Calls} {
+ whole := threadRows(ledgerOfAt(p, Filter{}, now, reader))
+ if p == All && len(whole) < 3 {
+ t.Fatalf("fixture: the whole ledger has %d thread rows: %+v", len(whole), whole)
+ }
+ if got := codexEffortRows(p, now, reader); !reflect.DeepEqual(got, whole) {
+ t.Fatalf("%s, %s:\n got %+v\nwant %+v", p, name, got, whole)
+ }
+ }
+ }
+}
+
+// A build of CodexModelEffort takes no more for a gateway call no Codex
+// session file's call can be matched to than a visit of the log does: it
+// made every such call a record, a packed row and a priced row, and over
+// ~720k calls that was most of the start's peak (#2776).
+func TestCodexModelEffortLetsUnrelatedCallsGo(t *testing.T) {
+ now, _ := effortFixture(t)
+ Append(Record{Time: now.Add(-time.Hour), Agent: "codex", Provider: "openai", Model: "m", Input: 20, Output: 3, Status: 200, ResponseID: "resp-1", Session: "main-a"})
+ const calls = 3000
+ for i := range calls {
+ Append(Record{Time: now.Add(-time.Duration(i) * time.Second), Agent: "claude-code", Provider: "anthropic", Model: "claude-opus-5-5", Input: 40 + i, Output: 4, Status: 200, RequestID: fmt.Sprintf("req_%d", i), Session: fmt.Sprintf("sess%d", i%50)})
+ }
+ measure := func(fn func()) uint64 {
+ fn() // anything a first read sets up once
+ var before, after runtime.MemStats
+ runtime.GC()
+ runtime.ReadMemStats(&before)
+ fn()
+ runtime.ReadMemStats(&after)
+ return after.TotalAlloc - before.TotalAlloc
+ }
+ // the session files read by a reader of their own: a build each ask
+ old := LogCalls
+ LogCalls = codexCalls
+ t.Cleanup(func() { LogCalls = old })
+ if got := CodexModelEffort(All); len(got["main-a"]) != 1 {
+ t.Fatalf("main-a's consumption: %+v", got)
+ }
+ visit := measure(func() { Visit(time.Time{}, func(Record) {}) })
+ build := measure(func() { CodexModelEffort(All) })
+ t.Logf("a build allocated %d bytes, a visit %d", build, visit)
+ // the visit itself, the thread's own rows and the sets of its ids
+ if build > visit+visit/2+256<<10 {
+ t.Fatalf("a build over %d unrelated calls allocated %d bytes, a visit of the log %d", calls, build, visit)
+ }
+}
diff --git a/internal/usage/codex_identity.go b/internal/usage/codex_identity.go
index a948f80ce..046b9068c 100644
--- a/internal/usage/codex_identity.go
+++ b/internal/usage/codex_identity.go
@@ -329,7 +329,7 @@ var effortBuilt func()
// CodexModelEffort reports each Codex thread's own priced ledger consumption.
func CodexModelEffort(p Period) map[string][]sessions.ModelEffort {
if LogCalls != nil { // synthetic logs carry no state to key on
- return codexModelEffort(LedgerOf(p, Filter{}).Rows)
+ return codexModelEffort(codexEffortRows(p, Clock(), LogCalls))
}
now := Clock()
st := readRequestState(now)
@@ -378,10 +378,71 @@ func CodexModelEffort(p Period) map[string][]sessions.ModelEffort {
// Only Codex's own calls carry a Codex thread: a gateway call is told
// its thread by the Codex call that has its response id, so the other
// agents' session files are not read for this.
- value = codexModelEffort(ledgerOfAt(p, Filter{}, now, codexCalls).Rows)
+ value = codexModelEffort(codexEffortRows(p, now, codexCalls))
return cloneEffort(value)
}
+// codexEffortRows are the rows of ledgerOfAt(p, Filter{}, now, reader) that
+// carry a Codex thread, in the same order, without the rest of the ledger.
+// A gateway call is told its thread only by the session file's call it is
+// paired with, and a session file's call is matched (and so not a row of
+// its own) only by a gateway call with its request id, its session or its
+// response id: only those gateway calls are kept from the log, each read
+// and let go as the log is visited. Over ~720k gateway calls a build held
+// every one of them three times over (a record, a packed row and a priced
+// row) at the start's peak (#2776).
+func codexEffortRows(p Period, now time.Time, reader func(time.Time) []sessions.Call) []Row {
+ since := p.Since(now)
+ gatewaySince := since
+ if !since.IsZero() {
+ gatewaySince = since.Add(-24 * time.Hour)
+ }
+ logs := reader(since)
+ if len(logs) == 0 {
+ return nil
+ }
+ recs := matchingRecords(gatewaySince, logs)
+ matched, pairs, actors, compactions := gatewayMatchesDetails(recs, logs)
+ // only a gateway call paired with a session file's call has a thread
+ paired := make([]Record, 0, len(pairs))
+ byRecord := make(map[int]int, len(pairs))
+ for i, r := range recs {
+ if call, ok := pairs[i]; ok {
+ byRecord[len(paired)] = call
+ paired = append(paired, r)
+ }
+ }
+ rows, _, _, _ := ledgerMatched(since, p.Until(now), Filter{}, paired, logs, nil, matched, byRecord, actors, compactions)
+ return slices.DeleteFunc(rows, func(r Row) bool { return r.codexActor == "" })
+}
+
+// matchingRecords are the gateway's calls from since on that can be matched
+// to one of logs, in the log's order: the ones with a response id, a request
+// id or a session one of them has (an agy call by its agent: agy names no
+// session). Any other gateway call leaves gatewayMatchesDetails' answer for
+// logs as it is.
+func matchingRecords(since time.Time, logs []sessions.Call) []Record {
+ responses, requests, sessionIDs := map[string]bool{}, map[string]bool{}, map[string]bool{}
+ agy := false
+ for _, c := range logs {
+ responses[c.ResponseID] = true
+ requests[c.RequestID] = true
+ sessionIDs[c.Session] = true
+ agy = agy || c.Agent == "agy"
+ }
+ delete(responses, "")
+ delete(requests, "")
+ delete(sessionIDs, "")
+ var out []Record
+ Visit(since, func(r Record) {
+ if responses[r.ResponseID] || requests[r.RequestID] || sessionIDs[r.NativeSession] || sessionIDs[r.Session] ||
+ agy && ReportedAs(r.Agent) == "agy" {
+ out = append(out, r)
+ }
+ })
+ return out
+}
+
func codexCalls(since time.Time) []sessions.Call { return sessions.AgentCalls(since, "codex") }
// forgetEffortPeriods drops the answers asked for longest ago, keeping p's