@tokentop/ttop 0.6.1 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokentop/ttop",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Real-time AI token usage monitor - htop for your API costs",
   "author": "Nigel Bazzeghin <nbazzeghin@gmail.com>",
   "license": "MIT",
@@ -34,14 +34,14 @@
     "analytics": "bun .opencode/skills/analytics/scripts/analytics.ts"
   },
   "dependencies": {
-    "@opentui/core": "0.1.87",
-    "@opentui/react": "0.1.87",
+    "@opentui/core": "0.1.98",
+    "@opentui/react": "0.1.98",
     "@tokentop/agent-claude-code": "^1.1.0",
     "@tokentop/agent-copilot-cli": "^1.0.0",
     "@tokentop/agent-cursor": "^1.2.0",
     "@tokentop/agent-gemini": "^1.0.0",
     "@tokentop/agent-opencode": "^1.0.0",
-    "@tokentop/plugin-sdk": "^1.4.0",
+    "@tokentop/plugin-sdk": "^1.5.0",
     "react": "^19.0.0",
     "react-devtools-core": "^7.0.1",
     "zod": "^4.0.0"

package/src/agents/aggregator.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import type { SessionUsageData } from "@tokentop/plugin-sdk";
 import { aggregateSessionUsage, deduplicateAggregates } from "./aggregator.ts";
 import type { AgentSessionAggregate } from "./types.ts";
 
@@ -201,7 +202,40 @@ describe("deduplicateAggregates", () => {
 // aggregateSessionUsage — basic sanity
 // ---------------------------------------------------------------------------
 describe("aggregateSessionUsage", () => {
-  const NOW = Date.now();
+  const NOW = new Date(2026, 3, 15, 12, 0, 0, 0).getTime();
+
+  function makeUsageRow(
+    overrides: Partial<SessionUsageData> &
+      Pick<SessionUsageData, "sessionId" | "tokens" | "timestamp">,
+  ): SessionUsageData {
+    return {
+      providerId: "anthropic",
+      modelId: "claude-sonnet-4",
+      ...overrides,
+    };
+  }
+
+  function aggregateSingleSession(rows: SessionUsageData[]) {
+    const result = aggregateSessionUsage({
+      agentId: "test",
+      agentName: "Test",
+      now: NOW,
+      rows,
+    });
+
+    expect(result).toHaveLength(1);
+    return result[0]!;
+  }
+
+  function getOnlyStream(rows: SessionUsageData[]) {
+    const session = aggregateSingleSession(rows);
+    expect(session.streams).toHaveLength(1);
+    return {
+      session,
+      stream: session.streams[0]!,
+      windowed: session._streamWindowedTokens?.get("anthropic::claude-sonnet-4"),
+    };
+  }
 
   test("groups rows by sessionId", () => {
     const result = aggregateSessionUsage({
@@ -303,4 +337,238 @@ describe("aggregateSessionUsage", () => {
     expect(active!.status).toBe("active");
     expect(idle!.status).toBe("idle");
   });
+
+  test("keeps all requests in the base bucket when every request is at or under 200K context", () => {
+    const { stream, session, windowed } = getOnlyStream([
+      makeUsageRow({ sessionId: "s1", timestamp: NOW, tokens: { input: 120_000, output: 1_000 } }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 80_000, output: 2_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 2_000,
+        tokens: { input: 200_000, output: 3_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 400_000, output: 6_000 });
+    expect(stream.longContextTokens).toBeUndefined();
+    expect(stream.longContextRequestCount).toBeUndefined();
+    expect(stream.hasLongContext).toBeUndefined();
+    expect(session.totals).toEqual({ input: 400_000, output: 6_000 });
+    expect(windowed).toEqual({
+      dayTokens: 406_000,
+      weekTokens: 406_000,
+      monthTokens: 406_000,
+      totalTokens: 406_000,
+    });
+  });
+
+  test("moves all requests into long-context bucket when every request exceeds 200K context", () => {
+    const { stream, windowed } = getOnlyStream([
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW,
+        tokens: { input: 210_000, output: 1_000, cacheRead: 5_000, cacheWrite: 2_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 220_000, output: 2_000, cacheRead: 10_000, cacheWrite: 4_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 0, output: 0 });
+    expect(stream.requestCount).toBe(2);
+    expect(stream.longContextTokens).toEqual({
+      input: 430_000,
+      output: 3_000,
+      cacheRead: 15_000,
+      cacheWrite: 6_000,
+    });
+    expect(stream.longContextRequestCount).toBe(2);
+    expect(stream.hasLongContext).toBe(true);
+    expect(windowed).toEqual({
+      dayTokens: 454_000,
+      weekTokens: 454_000,
+      monthTokens: 454_000,
+      totalTokens: 454_000,
+      longContextDayTokens: 454_000,
+      longContextWeekTokens: 454_000,
+      longContextMonthTokens: 454_000,
+      longContextTotalTokens: 454_000,
+    });
+  });
+
+  test("splits mixed requests into base and long-context buckets", () => {
+    const { stream } = getOnlyStream([
+      makeUsageRow({ sessionId: "s1", timestamp: NOW, tokens: { input: 100_000, output: 1_000 } }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 120_000, output: 2_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 2_000,
+        tokens: { input: 180_000, output: 3_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 3_000,
+        tokens: { input: 210_000, output: 4_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 4_000,
+        tokens: { input: 190_000, output: 5_000, cacheRead: 20_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 400_000, output: 6_000 });
+    expect(stream.longContextTokens).toEqual({ input: 400_000, output: 9_000, cacheRead: 20_000 });
+    expect(stream.requestCount).toBe(5);
+    expect(stream.longContextRequestCount).toBe(2);
+    expect(stream.hasLongContext).toBe(true);
+  });
+
+  test("treats exactly 200,000 context tokens as base bucket", () => {
+    const { stream, windowed } = getOnlyStream([
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW,
+        tokens: { input: 150_000, output: 7_000, cacheRead: 30_000, cacheWrite: 20_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({
+      input: 150_000,
+      output: 7_000,
+      cacheRead: 30_000,
+      cacheWrite: 20_000,
+    });
+    expect(stream.longContextTokens).toBeUndefined();
+    expect(stream.longContextRequestCount).toBeUndefined();
+    expect(stream.hasLongContext).toBeUndefined();
+    expect(windowed?.longContextTotalTokens).toBeUndefined();
+  });
+
+  test("moves 200,001 context tokens into long-context bucket", () => {
+    const { stream, windowed } = getOnlyStream([
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW,
+        tokens: { input: 150_000, output: 7_000, cacheRead: 30_001, cacheWrite: 20_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 0, output: 0 });
+    expect(stream.longContextTokens).toEqual({
+      input: 150_000,
+      output: 7_000,
+      cacheRead: 30_001,
+      cacheWrite: 20_000,
+    });
+    expect(stream.longContextRequestCount).toBe(1);
+    expect(stream.hasLongContext).toBe(true);
+    expect(windowed?.longContextTotalTokens).toBe(207_001);
+  });
+
+  test("uses cache tokens when cache-only growth crosses the threshold", () => {
+    const { stream } = getOnlyStream([
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW,
+        tokens: { input: 50_000, output: 1_000, cacheRead: 180_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 0, output: 0 });
+    expect(stream.longContextTokens).toEqual({ input: 50_000, output: 1_000, cacheRead: 180_000 });
+    expect(stream.longContextRequestCount).toBe(1);
+  });
+
+  test("treats missing cacheRead and cacheWrite as zero when computing context size", () => {
+    const { stream } = getOnlyStream([
+      makeUsageRow({ sessionId: "s1", timestamp: NOW, tokens: { input: 199_999, output: 1_000 } }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 200_001, output: 2_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 199_999, output: 1_000 });
+    expect(stream.longContextTokens).toEqual({ input: 200_001, output: 2_000 });
+    expect(stream.longContextRequestCount).toBe(1);
+  });
+
+  test("splits windowed tokens correctly between total and long-context buckets", () => {
+    const { windowed } = getOnlyStream([
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 210_000, output: 1_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 60 * 60 * 1000,
+        tokens: { input: 90_000, output: 2_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 2 * 24 * 60 * 60 * 1000,
+        tokens: { input: 205_000, output: 3_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 10 * 24 * 60 * 60 * 1000,
+        tokens: { input: 80_000, output: 4_000 },
+      }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: new Date(
+          new Date(NOW).getFullYear(),
+          new Date(NOW).getMonth() - 1,
+          15,
+        ).getTime(),
+        tokens: { input: 220_000, output: 5_000 },
+      }),
+    ]);
+
+    expect(windowed).toEqual({
+      dayTokens: 303_000,
+      weekTokens: 511_000,
+      monthTokens: 595_000,
+      totalTokens: 820_000,
+      longContextDayTokens: 211_000,
+      longContextWeekTokens: 419_000,
+      longContextMonthTokens: 419_000,
+      longContextTotalTokens: 644_000,
+    });
+  });
+
+  test("does not produce division-by-zero or NaN artifacts when every request is long-context", () => {
+    const { stream, session, windowed } = getOnlyStream([
+      makeUsageRow({ sessionId: "s1", timestamp: NOW, tokens: { input: 300_000, output: 5_000 } }),
+      makeUsageRow({
+        sessionId: "s1",
+        timestamp: NOW - 1_000,
+        tokens: { input: 250_000, output: 6_000 },
+      }),
+    ]);
+
+    expect(stream.tokens).toEqual({ input: 0, output: 0 });
+    expect(stream.longContextTokens).toEqual({ input: 550_000, output: 11_000 });
+    expect(stream.longContextRequestCount).toBe(2);
+    expect(stream.hasLongContext).toBe(true);
+    expect(Number.isNaN(stream.tokens.input)).toBe(false);
+    expect(Number.isNaN(stream.tokens.output)).toBe(false);
+    expect(Number.isNaN(session.totals.input)).toBe(false);
+    expect(Number.isNaN(session.totals.output)).toBe(false);
+    expect(Number.isNaN(windowed!.totalTokens)).toBe(false);
+    expect(Number.isNaN(windowed!.longContextTotalTokens!)).toBe(false);
+  });
 });

package/src/agents/aggregator.ts

@@ -1,4 +1,5 @@
 import type { SessionUsageData } from "@tokentop/plugin-sdk";
+import { LONG_CONTEXT_THRESHOLD } from "../pricing/estimator.ts";
 import {
   type AgentId,
   type AgentName,
@@ -64,9 +65,35 @@ interface StreamAccumulator {
   key: StreamKey;
   tokens: TokenCounts;
   requestCount: number;
+  longContextTokens?: TokenCounts;
+  longContextRequestCount?: number;
   windowed: StreamWindowedTokens;
 }
 
+function zeroTokens(): TokenCounts {
+  return { input: 0, output: 0 };
+}
+
+function normalizeTokens(tokens: TokenCounts): TokenCounts {
+  const normalized: TokenCounts = {
+    input: tokens.input,
+    output: tokens.output,
+  };
+
+  const cacheRead = tokens.cacheRead ?? 0;
+  const cacheWrite = tokens.cacheWrite ?? 0;
+
+  if (cacheRead > 0) normalized.cacheRead = cacheRead;
+  if (cacheWrite > 0) normalized.cacheWrite = cacheWrite;
+
+  return normalized;
+}
+
+function getContextSize(tokens: TokenCounts): number {
+  // contextSize = input + cacheRead + cacheWrite — the full prompt context sent to the model
+  return tokens.input + (tokens.cacheRead ?? 0) + (tokens.cacheWrite ?? 0);
+}
+
 export function aggregateSessionUsage(options: AggregateOptions): AgentSessionAggregate[] {
   const {
     agentId,
@@ -134,21 +161,52 @@ export function aggregateSessionUsage(options: AggregateOptions): AgentSessionAg
     if (!stream) {
       stream = {
         key: streamKey,
-        tokens: { input: 0, output: 0 },
+        tokens: zeroTokens(),
         requestCount: 0,
         windowed: { dayTokens: 0, weekTokens: 0, monthTokens: 0, totalTokens: 0 },
       };
       session.streamMap.set(streamKeyStr, stream);
     }
 
-    stream.tokens = sumTokens(stream.tokens, row.tokens);
+    const contextSize = getContextSize(row.tokens);
+    const bucketTokens = normalizeTokens(row.tokens);
+
+    if (contextSize > LONG_CONTEXT_THRESHOLD) {
+      stream.longContextTokens = sumTokens(stream.longContextTokens ?? zeroTokens(), bucketTokens);
+      stream.longContextRequestCount = (stream.longContextRequestCount ?? 0) + 1;
+    } else {
+      stream.tokens = sumTokens(stream.tokens, bucketTokens);
+    }
+
     stream.requestCount += 1;
 
     const msgTokens = totalTokenCount(row.tokens);
     stream.windowed.totalTokens += msgTokens;
-    if (row.timestamp >= startOfDay) stream.windowed.dayTokens += msgTokens;
-    if (row.timestamp >= startOfWeek) stream.windowed.weekTokens += msgTokens;
-    if (row.timestamp >= startOfMonth) stream.windowed.monthTokens += msgTokens;
+    if (contextSize > LONG_CONTEXT_THRESHOLD) {
+      stream.windowed.longContextTotalTokens =
+        (stream.windowed.longContextTotalTokens ?? 0) + msgTokens;
+    }
+    if (row.timestamp >= startOfDay) {
+      stream.windowed.dayTokens += msgTokens;
+      if (contextSize > LONG_CONTEXT_THRESHOLD) {
+        stream.windowed.longContextDayTokens =
+          (stream.windowed.longContextDayTokens ?? 0) + msgTokens;
+      }
+    }
+    if (row.timestamp >= startOfWeek) {
+      stream.windowed.weekTokens += msgTokens;
+      if (contextSize > LONG_CONTEXT_THRESHOLD) {
+        stream.windowed.longContextWeekTokens =
+          (stream.windowed.longContextWeekTokens ?? 0) + msgTokens;
+      }
+    }
+    if (row.timestamp >= startOfMonth) {
+      stream.windowed.monthTokens += msgTokens;
+      if (contextSize > LONG_CONTEXT_THRESHOLD) {
+        stream.windowed.longContextMonthTokens =
+          (stream.windowed.longContextMonthTokens ?? 0) + msgTokens;
+      }
+    }
     if ((row.metadata?.isEstimated as boolean) === true) {
       session.hasEstimated = true;
     }
@@ -168,13 +226,24 @@ export function aggregateSessionUsage(options: AggregateOptions): AgentSessionAg
     let totalRequestCount = 0;
 
     for (const [streamKeyStr, stream] of session.streamMap) {
-      streams.push({
+      const totalStreamTokens = sumTokens(stream.tokens, stream.longContextTokens ?? zeroTokens());
+      const streamAggregate: AgentSessionStream = {
         providerId: stream.key.providerId,
         modelId: stream.key.modelId,
         tokens: stream.tokens,
         requestCount: stream.requestCount,
-      });
-      totals = sumTokens(totals, stream.tokens);
+      };
+
+      if (stream.longContextTokens) {
+        streamAggregate.longContextTokens = stream.longContextTokens;
+      }
+      if (stream.longContextRequestCount) {
+        streamAggregate.longContextRequestCount = stream.longContextRequestCount;
+        streamAggregate.hasLongContext = true;
+      }
+
+      streams.push(streamAggregate);
+      totals = sumTokens(totals, totalStreamTokens);
       totalRequestCount += stream.requestCount;
       streamWindowedTokens.set(streamKeyStr, stream.windowed);
     }
@@ -236,3 +305,122 @@ export function deduplicateAggregates(
   }
   return Array.from(deduped.values());
 }
+
+export interface CrossAgentShadowMetadata {
+  kind: "cross-agent-shadow";
+  shadowOfAgentId: string;
+  shadowOfSessionId: string;
+  reason: "proxy-sdk-session-id" | "heuristic";
+}
+
+export function isCrossAgentShadow(session: AgentSessionAggregate): boolean {
+  const dedup = session.metadata?.dedup as { kind?: string } | undefined;
+  return dedup?.kind === "cross-agent-shadow";
+}
+
+export function selectEffectiveSessions(
+  sessions: AgentSessionAggregate[],
+): AgentSessionAggregate[] {
+  return sessions.filter((s) => !isCrossAgentShadow(s));
+}
+
+const CROSS_AGENT_TIMESTAMP_TOLERANCE_MS = 120_000;
+
+function normalizeProjectPath(p: string | undefined): string {
+  if (!p) return "";
+  return p.replace(/\/+$/, "");
+}
+
+export function markCrossAgentShadows(
+  aggregates: AgentSessionAggregate[],
+): AgentSessionAggregate[] {
+  const opencodeSessions: AgentSessionAggregate[] = [];
+  const claudeCodeById = new Map<string, AgentSessionAggregate>();
+  const claudeCodeByPath = new Map<string, AgentSessionAggregate[]>();
+  const ccStreamKeys = new Map<string, string[]>();
+
+  for (const agg of aggregates) {
+    if (agg.agentId === "opencode") {
+      opencodeSessions.push(agg);
+    } else if (agg.agentId === "claude-code") {
+      claudeCodeById.set(agg.sessionId, agg);
+      const path = normalizeProjectPath(agg.projectPath);
+      if (path) {
+        const bucket = claudeCodeByPath.get(path);
+        if (bucket) bucket.push(agg);
+        else claudeCodeByPath.set(path, [agg]);
+      }
+      const keys: string[] = new Array(agg.streams.length);
+      for (let i = 0; i < agg.streams.length; i++) {
+        const s = agg.streams[i]!;
+        keys[i] = `${s.providerId}::${s.modelId}`;
+      }
+      ccStreamKeys.set(agg.sessionId, keys);
+    }
+  }
+
+  if (opencodeSessions.length === 0 || claudeCodeById.size === 0) {
+    return aggregates;
+  }
+
+  const claimed = new Set<string>();
+
+  for (const oc of opencodeSessions) {
+    const proxy = oc.metadata?.proxy as { sdkSessionId?: string } | undefined;
+    if (!proxy?.sdkSessionId) continue;
+    const cc = claudeCodeById.get(proxy.sdkSessionId);
+    if (!cc || claimed.has(cc.sessionId)) continue;
+    cc.metadata = {
+      ...cc.metadata,
+      dedup: {
+        kind: "cross-agent-shadow",
+        shadowOfAgentId: "opencode",
+        shadowOfSessionId: oc.sessionId,
+        reason: "proxy-sdk-session-id",
+      } satisfies CrossAgentShadowMetadata,
+    };
+    claimed.add(cc.sessionId);
+  }
+
+  for (const oc of opencodeSessions) {
+    if (oc.streams.length === 0) continue;
+    const ocPath = normalizeProjectPath(oc.projectPath);
+    if (!ocPath) continue;
+    const bucket = claudeCodeByPath.get(ocPath);
+    if (!bucket) continue;
+
+    const ocKeys = new Set<string>();
+    for (const s of oc.streams) ocKeys.add(`${s.providerId}::${s.modelId}`);
+
+    for (const cc of bucket) {
+      if (claimed.has(cc.sessionId)) continue;
+      if (Math.abs(oc.lastActivityAt - cc.lastActivityAt) > CROSS_AGENT_TIMESTAMP_TOLERANCE_MS) {
+        continue;
+      }
+      const ccKeys = ccStreamKeys.get(cc.sessionId);
+      if (!ccKeys || ccKeys.length === 0) continue;
+      let overlap = false;
+      for (const k of ccKeys) {
+        if (ocKeys.has(k)) {
+          overlap = true;
+          break;
+        }
+      }
+      if (!overlap) continue;
+
+      cc.metadata = {
+        ...cc.metadata,
+        dedup: {
+          kind: "cross-agent-shadow",
+          shadowOfAgentId: "opencode",
+          shadowOfSessionId: oc.sessionId,
+          reason: "heuristic",
+        } satisfies CrossAgentShadowMetadata,
+      };
+      claimed.add(cc.sessionId);
+      break;
+    }
+  }
+
+  return aggregates;
+}