Skip to content

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

Fix token double-count from dual Claude Code telemetry channels

shukieshaha8fb55d2beac
diff --git a/cli/beacon/internal/endpoint/tokens/tokens.go b/cli/beacon/internal/endpoint/tokens/tokens.go
index 36bbd553..f519fce9 100644
--- a/cli/beacon/internal/endpoint/tokens/tokens.go
+++ b/cli/beacon/internal/endpoint/tokens/tokens.go
@@ -150,6 +150,7 @@ func Aggregate(events []schema.Event, opts Options) Report {
}
report := Report{TotalEvents: len(events)}
usageEvents := collectUsageEvents(events)
+ usageEvents = dedupeOverlappingChannels(usageEvents)
resolveCumulativeSeries(usageEvents)
byModel := map[string]*Usage{}
@@ -249,6 +250,77 @@ func collectUsageEvents(events []schema.Event) []*usageEvent {
return out
}
+// dedupeOverlappingChannels removes double-counted usage when a runtime reports
+// the same tokens through two OTel channels. Claude Code emits each request's
+// usage on both a claude_code.api_request log record and the
+// claude_code.token.usage metric, so ingesting both doubles every token field.
+//
+// The log/span channel (events without a metric_name) is the token source of
+// truth: it carries full per-request usage under the base model name. For each
+// (harness, session) scope, any usage field that channel reports is zeroed on
+// the scope's metric-channel events. Fields the log channel never reports
+// (Claude Code reports cost only on claude_code.cost.usage) survive on the
+// metric channel, so cost still lands exactly once. Runtimes that emit only
+// metrics have no log/span channel in scope and are left untouched.
+func dedupeOverlappingChannels(events []*usageEvent) []*usageEvent {
+ type fieldSet struct {
+ input, output, cacheRead, cacheCreation, reasoning, cost bool
+ }
+ scopeKey := func(ue *usageEvent) string { return ue.harness + "\x00" + ue.session }
+ logFields := map[string]*fieldSet{}
+ for _, ue := range events {
+ if ue.metricName != "" {
+ continue
+ }
+ fs := logFields[scopeKey(ue)]
+ if fs == nil {
+ fs = &fieldSet{}
+ logFields[scopeKey(ue)] = fs
+ }
+ fs.input = fs.input || ue.usage.InputTokens != 0
+ fs.output = fs.output || ue.usage.OutputTokens != 0
+ fs.cacheRead = fs.cacheRead || ue.usage.CacheReadInputTokens != 0
+ fs.cacheCreation = fs.cacheCreation || ue.usage.CacheCreationInputTokens != 0
+ fs.reasoning = fs.reasoning || ue.usage.ReasoningOutputTokens != 0
+ fs.cost = fs.cost || ue.usage.CostUSD != 0
+ }
+ if len(logFields) == 0 {
+ return events
+ }
+ out := events[:0]
+ for _, ue := range events {
+ if ue.metricName != "" {
+ if fs := logFields[scopeKey(ue)]; fs != nil {
+ if fs.input {
+ ue.usage.InputTokens = 0
+ }
+ if fs.output {
+ ue.usage.OutputTokens = 0
+ }
+ if fs.cacheRead {
+ ue.usage.CacheReadInputTokens = 0
+ }
+ if fs.cacheCreation {
+ ue.usage.CacheCreationInputTokens = 0
+ }
+ if fs.reasoning {
+ ue.usage.ReasoningOutputTokens = 0
+ }
+ if fs.cost {
+ ue.usage.CostUSD = 0
+ }
+ // Drop a metric event left with no usage so it neither inflates
+ // event counts nor seeds an empty cumulative series.
+ if ue.usage.TotalTokens() == 0 && ue.usage.ReasoningOutputTokens == 0 && ue.usage.CostUSD == 0 {
+ continue
+ }
+ }
+ }
+ out = append(out, ue)
+ }
+ return out
+}
+
// resolveCumulativeSeries rewrites cumulative metric contributions into
// per-interval deltas. Each cumulative series is identified by harness,
// session, model, metric name, and the single usage field the datapoint set.
diff --git a/cli/beacon/internal/endpoint/tokens/tokens_test.go b/cli/beacon/internal/endpoint/tokens/tokens_test.go
index 1db2c973..ade970f0 100644
--- a/cli/beacon/internal/endpoint/tokens/tokens_test.go
+++ b/cli/beacon/internal/endpoint/tokens/tokens_test.go
@@ -73,6 +73,65 @@ func TestAggregateSumsDeltaUsageAcrossGroups(t *testing.T) {
}
}
+func TestAggregateDedupesDualChannelUsage(t *testing.T) {
+ // Claude Code reports each request's usage on both a claude_code.api_request
+ // log record (no metric_name) and the claude_code.token.usage metric, under
+ // the base and 1M-context model names respectively. Counting both doubles
+ // every token field; cost rides only on claude_code.cost.usage.
+ metric := func(name string, mutate func(*schema.Event)) schema.Event {
+ return usageEventFixture("2026-06-11T10:00:05Z", "claude_code", "s1", "claude-opus-4-6[1m]", func(e *schema.Event) {
+ mutate(e)
+ e.Raw = map[string]interface{}{"metric_name": name, "metric_temporality": "Delta"}
+ })
+ }
+ events := []schema.Event{
+ // Log/span channel: full per-request usage, base model name, no cost.
+ usageEventFixture("2026-06-11T10:00:00Z", "claude_code", "s1", "claude-opus-4-6", func(e *schema.Event) {
+ e.Event.Action = "tool.invoked"
+ e.Message = "claude_code.api_request"
+ e.GenAI.Usage.InputTokens = int64Ptr(11)
+ e.GenAI.Usage.OutputTokens = int64Ptr(826)
+ e.GenAI.Usage.CacheRead = &schema.GenAIUsageCacheReadInfo{InputTokens: int64Ptr(119393)}
+ e.GenAI.Usage.CacheCreation = &schema.GenAIUsageCacheCreationInfo{InputTokens: int64Ptr(15751)}
+ }),
+ // Metric channel: same tokens, field-split (must be suppressed) plus cost (must survive).
+ metric("claude_code.token.usage", func(e *schema.Event) { e.GenAI.Usage.InputTokens = int64Ptr(11) }),
+ metric("claude_code.token.usage", func(e *schema.Event) { e.GenAI.Usage.OutputTokens = int64Ptr(826) }),
+ metric("claude_code.token.usage", func(e *schema.Event) {
+ e.GenAI.Usage.CacheRead = &schema.GenAIUsageCacheReadInfo{InputTokens: int64Ptr(119393)}
+ }),
+ metric("claude_code.token.usage", func(e *schema.Event) {
+ e.GenAI.Usage.CacheCreation = &schema.GenAIUsageCacheCreationInfo{InputTokens: int64Ptr(15751)}
+ }),
+ metric("claude_code.cost.usage", func(e *schema.Event) { e.GenAI.Usage.CostUSD = float64Ptr(0.1788) }),
+ // Metrics-only scope (no log/span channel): must be left untouched.
+ usageEventFixture("2026-06-11T10:01:00Z", "codex", "s2", "gpt-5", func(e *schema.Event) {
+ e.GenAI.Usage.InputTokens = int64Ptr(500)
+ e.Raw = map[string]interface{}{"metric_name": "gen_ai.client.token.usage", "metric_temporality": "Delta"}
+ }),
+ }
+
+ report := Aggregate(events, Options{})
+ if got := report.Totals; got.InputTokens != 511 || got.OutputTokens != 826 ||
+ got.CacheReadInputTokens != 119393 || got.CacheCreationInputTokens != 15751 || got.CostUSD != 0.1788 {
+ t.Fatalf("totals double-counted or dropped: %#v", got)
+ }
+ // Base model name carries the deduped tokens; the [1m] metric name carries cost only.
+ byModel := map[string]Usage{}
+ for _, g := range report.ByModel {
+ byModel[g.Key] = g.Usage
+ }
+ if base := byModel["claude-opus-4-6"]; base.InputTokens != 11 || base.OutputTokens != 826 || base.CacheReadInputTokens != 119393 {
+ t.Fatalf("base model tokens = %#v", base)
+ }
+ if oneM := byModel["claude-opus-4-6[1m]"]; oneM.TotalTokens() != 0 || oneM.CostUSD != 0.1788 {
+ t.Fatalf("[1m] model should carry cost only, got %#v", oneM)
+ }
+ if codex := byModel["gpt-5"]; codex.InputTokens != 500 {
+ t.Fatalf("metrics-only scope was dropped: %#v", codex)
+ }
+}
+
func TestAggregateDedupesCumulativeSeries(t *testing.T) {
cumulative := func(ts string, value int64) schema.Event {
return usageEventFixture(ts, "claude_code", "s1", "claude-sonnet-4-5", func(e *schema.Event) {