@tokentop/ttop 0.6.0 → 0.7.0

package/src/agents/costing.ts

@@ -1,34 +1,21 @@
+import type { CostBreakdown, ModelPricing } from "@tokentop/plugin-sdk";
 import { estimateCost, getPricing } from "@/pricing/index.ts";
 import type { AgentSessionAggregate, AgentSessionStream, StreamCostBreakdown } from "./types.ts";
 
 export async function priceStream(stream: AgentSessionStream): Promise<AgentSessionStream> {
   const pricing = await getPricing(stream.providerId, stream.modelId);
 
-  if (!pricing) {
-    return { ...stream, pricingSource: "unknown" };
-  }
-
-  const breakdown = estimateCost(stream.tokens, pricing);
-  const source = pricing.source === "models.dev" ? "models.dev" : "fallback";
-
-  const costBreakdown: StreamCostBreakdown = {
-    total: breakdown.total,
-    input: breakdown.input ?? 0,
-    output: breakdown.output ?? 0,
-  };
-  if (breakdown.cacheRead) costBreakdown.cacheRead = breakdown.cacheRead;
-  if (breakdown.cacheWrite) costBreakdown.cacheWrite = breakdown.cacheWrite;
-
-  return {
-    ...stream,
-    costUsd: breakdown.total,
-    costBreakdown,
-    pricingSource: source,
-  };
+  return priceStreamWithPricing(stream, pricing).stream;
 }
 
 export async function priceSession(session: AgentSessionAggregate): Promise<AgentSessionAggregate> {
-  const pricedStreams = await Promise.all(session.streams.map(priceStream));
+  const pricedResults = await Promise.all(
+    session.streams.map(async (stream) => {
+      const pricing = await getPricing(stream.providerId, stream.modelId);
+      return priceStreamWithPricing(stream, pricing);
+    }),
+  );
+  const pricedStreams = pricedResults.map((result) => result.stream);
 
   const totalCostUsd = pricedStreams.reduce((sum, s) => {
     return sum + (s.costUsd ?? 0);
@@ -41,18 +28,37 @@ export async function priceSession(session: AgentSessionAggregate): Promise<Agen
   let costInMonth = 0;
 
   if (hasAnyCost && session._streamWindowedTokens) {
-    for (const stream of pricedStreams) {
-      const streamCost = stream.costUsd ?? 0;
+    for (const result of pricedResults) {
+      const streamCost = result.stream.costUsd ?? 0;
       if (streamCost === 0) continue;
 
-      const keyStr = `${stream.providerId}::${stream.modelId}`;
+      const keyStr = `${result.stream.providerId}::${result.stream.modelId}`;
       const windowed = session._streamWindowedTokens.get(keyStr);
-      if (!windowed || windowed.totalTokens === 0) continue;
+      if (!windowed) continue;
 
-      const ratio = 1 / windowed.totalTokens;
-      costInDay += streamCost * windowed.dayTokens * ratio;
-      costInWeek += streamCost * windowed.weekTokens * ratio;
-      costInMonth += streamCost * windowed.monthTokens * ratio;
+      if (result.baseBreakdown.total > 0 && windowed.totalTokens > 0) {
+        const baseRatio = 1 / windowed.totalTokens;
+        costInDay += result.baseBreakdown.total * windowed.dayTokens * baseRatio;
+        costInWeek += result.baseBreakdown.total * windowed.weekTokens * baseRatio;
+        costInMonth += result.baseBreakdown.total * windowed.monthTokens * baseRatio;
+      }
+
+      const longContextTotalTokens = windowed.longContextTotalTokens ?? 0;
+      if (result.longContextBreakdown.total > 0 && longContextTotalTokens > 0) {
+        const longContextRatio = 1 / longContextTotalTokens;
+        costInDay +=
+          result.longContextBreakdown.total *
+          (windowed.longContextDayTokens ?? 0) *
+          longContextRatio;
+        costInWeek +=
+          result.longContextBreakdown.total *
+          (windowed.longContextWeekTokens ?? 0) *
+          longContextRatio;
+        costInMonth +=
+          result.longContextBreakdown.total *
+          (windowed.longContextMonthTokens ?? 0) *
+          longContextRatio;
+      }
     }
   }
 
@@ -69,8 +75,116 @@ export async function priceSession(session: AgentSessionAggregate): Promise<Agen
   return result;
 }
 
+type PricedStreamResult = {
+  stream: AgentSessionStream;
+  baseBreakdown: CostBreakdown;
+  longContextBreakdown: CostBreakdown;
+};
+
+function priceStreamWithPricing(
+  stream: AgentSessionStream,
+  pricing: ModelPricing | null,
+): PricedStreamResult {
+  const hasLongContext = (stream.longContextRequestCount ?? 0) > 0;
+
+  if (!pricing) {
+    return {
+      stream: {
+        ...stream,
+        ...(hasLongContext ? { hasLongContext: true } : {}),
+        pricingSource: "unknown",
+      },
+      baseBreakdown: zeroCostBreakdown(),
+      longContextBreakdown: zeroCostBreakdown(),
+    };
+  }
+
+  const baseBreakdown = estimateCost(stream.tokens, pricing);
+  const longContextBreakdown = stream.longContextTokens
+    ? estimateCost(
+        stream.longContextTokens,
+        hasLongContextPricing(pricing) ? buildLongContextPricing(pricing) : pricing,
+      )
+    : zeroCostBreakdown();
+  const breakdown = sumCostBreakdowns(baseBreakdown, longContextBreakdown);
+  const source = pricing.source === "models.dev" ? "models.dev" : "fallback";
+
+  return {
+    stream: {
+      ...stream,
+      ...(hasLongContext ? { hasLongContext: true } : {}),
+      costUsd: breakdown.total,
+      costBreakdown: toStreamCostBreakdown(breakdown),
+      pricingSource: source,
+    },
+    baseBreakdown,
+    longContextBreakdown,
+  };
+}
+
 export async function priceSessions(
   sessions: AgentSessionAggregate[],
 ): Promise<AgentSessionAggregate[]> {
   return Promise.all(sessions.map(priceSession));
 }
+
+function hasLongContextPricing(pricing: ModelPricing): boolean {
+  return (
+    pricing.longContextInput !== undefined ||
+    pricing.longContextOutput !== undefined ||
+    pricing.longContextCacheRead !== undefined ||
+    pricing.longContextCacheWrite !== undefined
+  );
+}
+
+function buildLongContextPricing(pricing: ModelPricing): ModelPricing {
+  return {
+    ...pricing,
+    input: pricing.longContextInput ?? pricing.input,
+    output: pricing.longContextOutput ?? pricing.output,
+    ...(pricing.longContextCacheRead !== undefined || pricing.cacheRead !== undefined
+      ? { cacheRead: pricing.longContextCacheRead ?? pricing.cacheRead }
+      : {}),
+    ...(pricing.longContextCacheWrite !== undefined || pricing.cacheWrite !== undefined
+      ? { cacheWrite: pricing.longContextCacheWrite ?? pricing.cacheWrite }
+      : {}),
+  };
+}
+
+function toStreamCostBreakdown(breakdown: CostBreakdown): StreamCostBreakdown {
+  const costBreakdown: StreamCostBreakdown = {
+    total: breakdown.total,
+    input: breakdown.input ?? 0,
+    output: breakdown.output ?? 0,
+  };
+  if (breakdown.cacheRead) costBreakdown.cacheRead = breakdown.cacheRead;
+  if (breakdown.cacheWrite) costBreakdown.cacheWrite = breakdown.cacheWrite;
+  return costBreakdown;
+}
+
+function sumCostBreakdowns(a: CostBreakdown, b: CostBreakdown): CostBreakdown {
+  const cacheRead = (a.cacheRead ?? 0) + (b.cacheRead ?? 0);
+  const cacheWrite = (a.cacheWrite ?? 0) + (b.cacheWrite ?? 0);
+  const breakdown: CostBreakdown = {
+    total: roundCost(a.total + b.total),
+    input: roundCost((a.input ?? 0) + (b.input ?? 0)),
+    output: roundCost((a.output ?? 0) + (b.output ?? 0)),
+    currency: a.currency,
+  };
+  if (cacheRead > 0) breakdown.cacheRead = roundCost(cacheRead);
+  if (cacheWrite > 0) breakdown.cacheWrite = roundCost(cacheWrite);
+  return breakdown;
+}
+
+function zeroCostBreakdown(): CostBreakdown {
+  return {
+    total: 0,
+    input: 0,
+    output: 0,
+    currency: "USD",
+  };
+}
+
+function roundCost(value: number): number {
+  return Math.round(value * 1_000_000) / 1_000_000;
+}

package/src/agents/types.ts

@@ -27,6 +27,9 @@ export interface AgentSessionStream {
   modelId: string;
   tokens: TokenCounts;
   requestCount: number;
+  longContextTokens?: TokenCounts;
+  longContextRequestCount?: number;
+  hasLongContext?: boolean;
   costUsd?: number;
   costBreakdown?: StreamCostBreakdown;
   pricingSource?: "models.dev" | "fallback" | "unknown";
@@ -37,6 +40,10 @@ export interface StreamWindowedTokens {
   weekTokens: number;
   monthTokens: number;
   totalTokens: number;
+  longContextDayTokens?: number;
+  longContextWeekTokens?: number;
+  longContextMonthTokens?: number;
+  longContextTotalTokens?: number;
 }
 
 export interface AgentSessionAggregate {

package/src/config/schema.ts

@@ -82,7 +82,7 @@ export const DEFAULT_CONFIG: AppConfig = {
   },
   notifications: {
     toastsEnabled: true,
-    soundEnabled: false,
+    soundEnabled: true,
   },
   budgets: {
     daily: null,

package/src/demo/simulator.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+import { DEMO_PRESETS, type DemoPreset, DemoSimulator } from "./simulator.ts";
+
+function summarize(sim: DemoSimulator) {
+  const { sessions } = sim.tick();
+  return {
+    count: sessions.length,
+    ids: sessions.map((s) => s.sessionId),
+    names: sessions.map((s) => s.sessionName),
+    totalCost: sessions.reduce((acc, s) => acc + (s.totalCostUsd ?? 0), 0),
+    totalTokens: sessions.reduce((acc, s) => acc + s.totals.input + s.totals.output, 0),
+    uniqueModels: new Set(sessions.flatMap((s) => s.streams.map((st) => st.modelId))).size,
+    uniqueProviders: new Set(sessions.flatMap((s) => s.streams.map((st) => st.providerId))).size,
+    uniqueProjects: new Set(sessions.map((s) => s.projectPath).filter(Boolean)).size,
+    uniqueAgents: new Set(sessions.map((s) => s.agentId)).size,
+  };
+}
+
+describe("DemoSimulator determinism", () => {
+  for (const preset of Object.keys(DEMO_PRESETS) as DemoPreset[]) {
+    test(`same seed + preset=${preset} produces identical sessions`, () => {
+      const a = summarize(new DemoSimulator({ seed: 42, preset }));
+      const b = summarize(new DemoSimulator({ seed: 42, preset }));
+
+      expect(b.count).toBe(a.count);
+      expect(b.ids).toEqual(a.ids);
+      expect(b.names).toEqual(a.names);
+      expect(b.totalCost).toBeCloseTo(a.totalCost, 6);
+      expect(b.totalTokens).toBe(a.totalTokens);
+    });
+  }
+
+  test("different seeds produce different sessions", () => {
+    const a = summarize(new DemoSimulator({ seed: 1, preset: "heavy" }));
+    const b = summarize(new DemoSimulator({ seed: 2, preset: "heavy" }));
+
+    expect(b.ids).not.toEqual(a.ids);
+    expect(b.totalCost).not.toBeCloseTo(a.totalCost, 2);
+  });
+
+  test("preset controls session count", () => {
+    expect(summarize(new DemoSimulator({ seed: 7, preset: "light" })).count).toBe(50);
+    expect(summarize(new DemoSimulator({ seed: 7, preset: "normal" })).count).toBe(500);
+    expect(summarize(new DemoSimulator({ seed: 7, preset: "heavy" })).count).toBe(4000);
+  });
+
+  test("repeated ticks keep historical sessions stable", () => {
+    const sim = new DemoSimulator({ seed: 99, preset: "normal" });
+    const first = sim.tick().sessions.filter((s) => s.endedAt !== undefined);
+    const second = sim.tick().sessions.filter((s) => s.endedAt !== undefined);
+
+    expect(second.length).toBe(first.length);
+    for (let i = 0; i < first.length; i++) {
+      expect(second[i]!.sessionId).toBe(first[i]!.sessionId);
+      expect(second[i]!.totalCostUsd).toBe(first[i]!.totalCostUsd);
+      expect(second[i]!.totals.input).toBe(first[i]!.totals.input);
+      expect(second[i]!.totals.output).toBe(first[i]!.totals.output);
+    }
+  });
+});
+
+describe("DemoSimulator variety", () => {
+  test("heavy preset produces enough models to stress the dashboard list", () => {
+    const s = summarize(new DemoSimulator({ seed: 42, preset: "heavy" }));
+    expect(s.uniqueModels).toBeGreaterThanOrEqual(12);
+    expect(s.uniqueProviders).toBeGreaterThanOrEqual(5);
+    expect(s.uniqueProjects).toBeGreaterThanOrEqual(10);
+    expect(s.uniqueAgents).toBeGreaterThanOrEqual(4);
+  });
+
+  test("normal preset still covers multiple models and agents", () => {
+    const s = summarize(new DemoSimulator({ seed: 42, preset: "normal" }));
+    expect(s.uniqueModels).toBeGreaterThanOrEqual(8);
+    expect(s.uniqueAgents).toBeGreaterThanOrEqual(3);
+  });
+
+  test("sessions are split between active and historical", () => {
+    const { sessions } = new DemoSimulator({ seed: 42, preset: "heavy" }).tick();
+    const active = sessions.filter((s) => s.endedAt === undefined);
+    const historical = sessions.filter((s) => s.endedAt !== undefined);
+    expect(active.length).toBeGreaterThan(0);
+    expect(active.length).toBeLessThanOrEqual(8);
+    expect(historical.length).toBeGreaterThan(active.length * 10);
+  });
+
+  test("heavy preset has enough recent sessions to trigger scrollbar", () => {
+    const { sessions } = new DemoSimulator({ seed: 42, preset: "heavy" }).tick();
+    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const recent = sessions.filter((s) => s.lastActivityAt >= cutoff);
+    expect(recent.length).toBeGreaterThanOrEqual(50);
+  });
+});