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.gonew file mode 100644index 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.goindex 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