Skip to content
Python
4.7 KB
Raw Blame
import { describe, expect, it } from "vitest";
import { addTurnUsage, emptyUsage, formatTokens, teamUsage, totalTokens, usageFromMessages, usageFromRecordings } from "./usage";
import type { TurnUsage } from "./types";

const turn = (over: Record<string, unknown> = {}) => ({
  model: "anthropic:claude-fable-5",
  input: 100,
  output: 20,
  cache_read: 50,
  cache_write: 10,
  ...over,
});

describe("addTurnUsage", () => {
  it("accumulates per model and tracks the latest prompt-side total as context", () => {
    let u = addTurnUsage(emptyUsage(), turn());
    u = addTurnUsage(u, turn({ input: 40, output: 5, cache_read: 200, cache_write: 0 }));
    const m = u.byModel["anthropic:claude-fable-5"];
    expect(m).toEqual({
      model: "anthropic:claude-fable-5",
      input: 140,
      output: 25,
      cache_read: 250,
      cache_write: 10,
    });
    // context = LAST turn's input + cache_read + cache_write, not a sum.
    expect(u.context).toBe(240);
  });

  it("keys separate models separately (mid-session switch)", () => {
    let u = addTurnUsage(emptyUsage(), turn());
    u = addTurnUsage(u, turn({ model: "gpt-5.5", input: 7 }));
    expect(Object.keys(u.byModel).sort()).toEqual(["anthropic:claude-fable-5", "gpt-5.5"]);
  });

  it("ignores malformed payloads and clamps negatives", () => {
    expect(addTurnUsage(emptyUsage(), null)).toEqual(emptyUsage());
    expect(addTurnUsage(emptyUsage(), "x")).toEqual(emptyUsage());
    const u = addTurnUsage(emptyUsage(), turn({ input: -5, output: "9" }));
    expect(u.byModel["anthropic:claude-fable-5"].input).toBe(0);
    expect(u.byModel["anthropic:claude-fable-5"].output).toBe(9);
  });

  it("buckets a missing model id under 'unknown'", () => {
    const u = addTurnUsage(emptyUsage(), turn({ model: undefined }));
    expect(u.byModel["unknown"].input).toBe(100);
  });
});

describe("usageFromMessages", () => {
  it("folds assistant usage sidecars and ignores everything else", () => {
    const u = usageFromMessages([
      { role: "user", content: "hi" },
      { role: "assistant", content: "a", usage: turn() as any },
      { role: "tool", content: "r", usage: turn() as any }, // wrong role — ignored
      { role: "assistant", content: "b" }, // no sidecar (older server) — ignored
      { role: "assistant", content: "c", usage: turn({ input: 300 }) as any },
    ]);
    expect(u.byModel["anthropic:claude-fable-5"].input).toBe(400);
    expect(u.context).toBe(360);
  });
});

describe("totalTokens / formatTokens", () => {
  it("totals across models and directions", () => {
    let u = addTurnUsage(emptyUsage(), turn());
    u = addTurnUsage(u, turn({ model: "gpt-5.5" }));
    expect(totalTokens(u)).toBe(360);
  });

  it("formats humane numbers", () => {
    expect(formatTokens(0)).toBe("0");
    expect(formatTokens(980)).toBe("980");
    expect(formatTokens(12_400)).toBe("12.4k");
    expect(formatTokens(982_000)).toBe("982k");
    expect(formatTokens(1_240_000)).toBe("1.24M");
    expect(formatTokens(NaN)).toBe("0");
  });
});

describe("teamUsage", () => {
  it("rolls the lead's live totals and the workers' persisted totals up by model", () => {
    const lead = addTurnUsage(emptyUsage(), {
      model: "anthropic:claude-opus-4-8", input: 100, output: 10, cache_read: 0, cache_write: 0,
    });
    const workers: { usage?: Record<string, TurnUsage & { turns?: number }> }[] = [
      { usage: { "anthropic:claude-opus-4-8": { input: 50, output: 5, cache_read: 20, cache_write: 0, turns: 2 } } },
      { usage: { "ollama:qwen3-coder:30b": { input: 7, output: 3, cache_read: 0, cache_write: 0, turns: 1 } } },
      {},
    ];
    const t = teamUsage(lead, workers);
    expect(t.byModel["anthropic:claude-opus-4-8"]).toMatchObject({ input: 150, output: 15, cache_read: 20 });
    expect(t.byModel["ollama:qwen3-coder:30b"]).toMatchObject({ input: 7, output: 3 });
    expect(totalTokens(t)).toBe(195);
    expect(t.context).toBe(lead.context); // the lead's window, not a sum
  });
});

describe("usageFromRecordings (P3-1)", () => {
  it("adds every recorded call of the team, helpers included", () => {
    const u = usageFromRecordings([
      { recorded: true, by_model_parts: { "model-a": { input: 1000, cache: 400, output: 100 }, "model-a (title)": { input: 50, cache: 0, output: 5 } } },
      { recorded: true, by_model_parts: { "model-b": { input: 200, cache: 0, output: 20 } } },
      null,
    ])!;
    // input already holds the cached part, so it is not added twice
    expect(totalTokens(u)).toBe(1000 + 100 + 50 + 5 + 200 + 20);
    expect(Object.keys(u.byModel).sort()).toEqual(["model-a", "model-b"]);
  });
  it("is null when no session was recorded, so the transcript count stays", () => {
    expect(usageFromRecordings([{ recorded: false }, null])).toBeNull();
    expect(usageFromRecordings([])).toBeNull();
  });
});