Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

Handle mixed Codex usage sources

shukieshahfe58c8ddd2f9
diff --git a/cli/beacon/internal/tokens/tokens.go b/cli/beacon/internal/tokens/tokens.go
index 08b98533..759ccb1c 100644
--- a/cli/beacon/internal/tokens/tokens.go
+++ b/cli/beacon/internal/tokens/tokens.go
@@ -348,9 +348,9 @@ func selectCodexUsageSource(events []*usageEvent, source string) ([]*usageEvent,
if source == CodexSourceAuto {
if hasSession {
out := events[:0]
- sessionKeys := codexSessionOverlapKeys(events)
+ suppressedOTLPKeys := codexOverlappingOTLPGroups(events)
for _, event := range events {
- if isCodexOTLPUsage(event) && sessionKeys[codexOverlapKey(event)] {
+ if isCodexOTLPUsage(event) && suppressedOTLPKeys[codexOTLPGroupKey(event)] {
summary.CodexOTLPSuppressed++
continue
}
@@ -398,17 +398,46 @@ func selectCodexUsageSource(events []*usageEvent, source string) ([]*usageEvent,
return out, summary
}
-func codexSessionOverlapKeys(events []*usageEvent) map[string]bool {
- keys := map[string]bool{}
+func codexOverlappingOTLPGroups(events []*usageEvent) map[string]bool {
+ type otlpGroup struct {
+ model string
+ usage Usage
+ }
+ sessionUsage := map[string]Usage{}
+ otlpGroups := map[string]*otlpGroup{}
for _, event := range events {
if isCodexSessionUsage(event) {
- keys[codexOverlapKey(event)] = true
+ sessionUsage[codexFullUsageKey(event)] = event.usage
+ continue
+ }
+ if isCodexOTLPUsage(event) {
+ key := codexOTLPGroupKey(event)
+ group := otlpGroups[key]
+ if group == nil {
+ group = &otlpGroup{model: event.model}
+ otlpGroups[key] = group
+ }
+ group.usage.add(event.usage)
}
}
- return keys
+ out := map[string]bool{}
+ for groupKey, group := range otlpGroups {
+ probe := &usageEvent{ts: parseCodexGroupTime(groupKey), model: group.model, usage: group.usage}
+ if _, ok := sessionUsage[codexFullUsageKey(probe)]; ok {
+ out[groupKey] = true
+ }
+ }
+ return out
+}
+
+func codexOTLPGroupKey(event *usageEvent) string {
+ return strings.Join([]string{
+ event.ts.UTC().Format(time.RFC3339),
+ event.model,
+ }, "\x00")
}
-func codexOverlapKey(event *usageEvent) string {
+func codexFullUsageKey(event *usageEvent) string {
return strings.Join([]string{
event.ts.UTC().Format(time.RFC3339),
event.model,
@@ -420,6 +449,15 @@ func codexOverlapKey(event *usageEvent) string {
}, "\x00")
}
+func parseCodexGroupTime(groupKey string) time.Time {
+ parts := strings.SplitN(groupKey, "\x00", 2)
+ if len(parts) == 0 {
+ return time.Time{}
+ }
+ ts, _ := time.Parse(time.RFC3339, parts[0])
+ return ts
+}
+
func isCodexSessionUsage(event *usageEvent) bool {
return isCodexHarness(event.harness) && strings.EqualFold(event.rawSource, "codex_session_jsonl")
}
diff --git a/cli/beacon/internal/tokens/tokens_test.go b/cli/beacon/internal/tokens/tokens_test.go
index 7f6fc7cc..fd698431 100644
--- a/cli/beacon/internal/tokens/tokens_test.go
+++ b/cli/beacon/internal/tokens/tokens_test.go
@@ -189,6 +189,35 @@ func TestAggregateAutoKeepsNonOverlappingCodexOTLPUsage(t *testing.T) {
}
}
+func TestAggregateAutoSuppressesSplitCodexOTLPDatapoints(t *testing.T) {
+ sessionEvent := usageEventFixture("2026-06-11T10:00:00Z", "codex_cli", "codex:s1", "gpt-5", func(e *schema.Event) {
+ e.GenAI.Usage.InputTokens = int64Ptr(40)
+ e.GenAI.Usage.OutputTokens = int64Ptr(10)
+ e.GenAI.Usage.CacheRead = &schema.GenAIUsageCacheReadInfo{InputTokens: int64Ptr(60)}
+ e.Raw = map[string]interface{}{"source": "codex_session_jsonl", "dedup_key": "session-turn-1"}
+ })
+ otlpInput := usageEventFixture("2026-06-11T10:00:00Z", "codex_cli", "", "gpt-5", func(e *schema.Event) {
+ e.GenAI.Usage.InputTokens = int64Ptr(40)
+ e.Raw = map[string]interface{}{"metric_name": "codex.turn.token_usage", "metric_temporality": "Delta"}
+ })
+ otlpOutput := usageEventFixture("2026-06-11T10:00:00Z", "codex_cli", "", "gpt-5", func(e *schema.Event) {
+ e.GenAI.Usage.OutputTokens = int64Ptr(10)
+ e.Raw = map[string]interface{}{"metric_name": "codex.turn.token_usage", "metric_temporality": "Delta"}
+ })
+ otlpCache := usageEventFixture("2026-06-11T10:00:00Z", "codex_cli", "", "gpt-5", func(e *schema.Event) {
+ e.GenAI.Usage.CacheRead = &schema.GenAIUsageCacheReadInfo{InputTokens: int64Ptr(60)}
+ e.Raw = map[string]interface{}{"metric_name": "codex.turn.token_usage", "metric_temporality": "Delta"}
+ })
+
+ report := Aggregate([]schema.Event{sessionEvent, otlpInput, otlpOutput, otlpCache}, Options{})
+ if report.Totals.InputTokens != 40 || report.Totals.OutputTokens != 10 || report.Totals.CacheReadInputTokens != 60 || report.Totals.Events != 1 {
+ t.Fatalf("auto totals = %#v, want session event only", report.Totals)
+ }
+ if report.Source == nil || report.Source.CodexOTLPSuppressed != 3 {
+ t.Fatalf("source summary = %#v, want three suppressed OTLP datapoints", report.Source)
+ }
+}
+
func TestAggregateDedupesCodexSessionUsageByRawDedupKey(t *testing.T) {
event := usageEventFixture("2026-06-11T10:00:00Z", "codex_cli", "codex:s1", "gpt-5", func(e *schema.Event) {
e.GenAI.Usage.InputTokens = int64Ptr(40)
diff --git a/pkg/asymptoteobserve/codexusage/lock_windows.go b/pkg/asymptoteobserve/codexusage/lock_windows.go
index f84fb824..605fac15 100644
--- a/pkg/asymptoteobserve/codexusage/lock_windows.go
+++ b/pkg/asymptoteobserve/codexusage/lock_windows.go
@@ -2,6 +2,28 @@
package codexusage
+import (
+ "os"
+ "path/filepath"
+ "time"
+)
+
func lockState(path string) (func(), error) {
- return func() {}, nil
+ if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+ return nil, err
+ }
+ lockPath := path + ".lock"
+ var lastErr error
+ for i := 0; i < 100; i++ {
+ f, err := os.OpenFile(lockPath, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0600)
+ if err == nil {
+ return func() {
+ _ = f.Close()
+ _ = os.Remove(lockPath)
+ }, nil
+ }
+ lastErr = err
+ time.Sleep(50 * time.Millisecond)
+ }
+ return nil, lastErr
}