The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
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.goindex 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.goindex 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) {