V1 TUI modules no longer load: replace ``{ id, tui }`` with
``Plugin.define({ id, setup })``, register the section on
``sidebar.content``, and expose commands through ``context.keymap.layer``.
Move balance, clock and usage state onto ``context.storage.store/memory``
so host subscribers rerender; plugin-created signals stayed stale in the
V2 renderer. Read V2 assistant messages (``type``,
``model.providerID``/``model.id``) and subscribe through ``context.data``.
Configure the package directory in ``cli.json`` instead of the source
file; document the V2 install. Typecheck, 49 unit tests and the live
GreenPT integration test pass, and the sidebar renders the balance.
158 lines
4.8 KiB
TypeScript
158 lines
4.8 KiB
TypeScript
import { describe, expect, it } from "vitest"
|
|
import {
|
|
addCreditsSpent,
|
|
applyMessages,
|
|
dayKey,
|
|
dayTotals,
|
|
monthTotals,
|
|
parseUsageDays,
|
|
pruneUsage,
|
|
recordMessage,
|
|
serializeUsage,
|
|
type UsageDays,
|
|
} from "../src/usage"
|
|
|
|
const NOW = new Date(2026, 9, 19, 15, 30, 0).getTime()
|
|
|
|
function assistantMessage(overrides: Record<string, unknown> = {}) {
|
|
return {
|
|
id: "msg-1",
|
|
type: "assistant",
|
|
model: { providerID: "greenpt", id: "glm-5.3-flash" },
|
|
cost: 0.01,
|
|
time: { created: NOW },
|
|
tokens: { input: 100, output: 50, reasoning: 10, cache: { read: 5, write: 2 } },
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
describe("dayKey", () => {
|
|
it("formats a local date key", () => {
|
|
expect(dayKey(new Date(2026, 0, 3, 8, 0).getTime())).toBe("2026-01-03")
|
|
})
|
|
})
|
|
|
|
describe("recordMessage", () => {
|
|
it("records tokens and cost per model", () => {
|
|
const days: UsageDays = {}
|
|
expect(recordMessage(days, assistantMessage())).toBe(true)
|
|
const day = days[dayKey(NOW)]!
|
|
expect(day.byModel["glm-5.3-flash"]!.requests).toBe(1)
|
|
expect(day.byModel["glm-5.3-flash"]!.cost).toBe(0.01)
|
|
expect(day.byModel["glm-5.3-flash"]!.tokens.input).toBe(100)
|
|
expect(day.byModel["glm-5.3-flash"]!.tokens.cacheRead).toBe(5)
|
|
})
|
|
|
|
it("is idempotent for the same message id", () => {
|
|
const days: UsageDays = {}
|
|
recordMessage(days, assistantMessage())
|
|
expect(recordMessage(days, assistantMessage())).toBe(false)
|
|
expect(Object.keys(days[dayKey(NOW)]!.byModel).length).toBe(1)
|
|
})
|
|
|
|
it("ignores non-GreenPT providers", () => {
|
|
const days: UsageDays = {}
|
|
expect(
|
|
recordMessage(
|
|
days,
|
|
assistantMessage({ model: { providerID: "anthropic", id: "claude-sonnet" } }),
|
|
),
|
|
).toBe(false)
|
|
expect(Object.keys(days).length).toBe(0)
|
|
})
|
|
|
|
it("buckets messages into their own day", () => {
|
|
const yesterday = NOW - 86_400_000
|
|
const days: UsageDays = {}
|
|
recordMessage(days, assistantMessage())
|
|
recordMessage(days, assistantMessage({ id: "msg-2", time: { created: yesterday } }))
|
|
expect(Object.keys(days).sort().length).toBe(2)
|
|
})
|
|
|
|
it("ignores messages without tokens or cost", () => {
|
|
const days: UsageDays = {}
|
|
expect(
|
|
recordMessage(days, assistantMessage({ cost: 0, tokens: undefined })),
|
|
).toBe(false)
|
|
expect(Object.keys(days).length).toBe(0)
|
|
})
|
|
})
|
|
|
|
describe("applyMessages", () => {
|
|
it("skips user messages and unknown shapes", () => {
|
|
const days: UsageDays = {}
|
|
applyMessages(days, [
|
|
{ id: "u1", type: "user" },
|
|
assistantMessage(),
|
|
null,
|
|
undefined,
|
|
])
|
|
expect(Object.keys(days[dayKey(NOW)]!.byModel).length).toBe(1)
|
|
})
|
|
})
|
|
|
|
describe("addCreditsSpent", () => {
|
|
it("accumulates positive deltas only", () => {
|
|
const days: UsageDays = {}
|
|
addCreditsSpent(days, NOW, 0.02)
|
|
addCreditsSpent(days, NOW, 0.01)
|
|
addCreditsSpent(days, NOW, -5)
|
|
addCreditsSpent(days, NOW, Number.NaN)
|
|
expect(days[dayKey(NOW)]!.creditsSpent).toBeCloseTo(0.03)
|
|
})
|
|
})
|
|
|
|
describe("totals", () => {
|
|
it("aggregates day and month with models sorted by cost", () => {
|
|
const days: UsageDays = {}
|
|
recordMessage(days, assistantMessage())
|
|
recordMessage(
|
|
days,
|
|
assistantMessage({ id: "msg-2", model: { providerID: "greenpt", id: "kimi-k2" }, cost: 0.05 }),
|
|
)
|
|
const day = dayTotals(days, NOW)
|
|
expect(day.byModel.map((row) => row.model)).toEqual(["kimi-k2", "glm-5.3-flash"])
|
|
expect(day.cost).toBeCloseTo(0.06)
|
|
expect(day.creditsSpent).toBe(0)
|
|
|
|
addCreditsSpent(days, NOW, 0.1)
|
|
expect(dayTotals(days, NOW).creditsSpent).toBeCloseTo(0.1)
|
|
expect(monthTotals(days, NOW).creditsSpent).toBeCloseTo(0.1)
|
|
})
|
|
|
|
it("returns zero totals for empty buckets", () => {
|
|
const totals = dayTotals({}, NOW)
|
|
expect(totals.creditsSpent).toBe(0)
|
|
expect(totals.byModel).toEqual([])
|
|
})
|
|
})
|
|
|
|
describe("pruneUsage", () => {
|
|
it("drops buckets older than the window", () => {
|
|
const days: UsageDays = {}
|
|
const old = NOW - 120 * 86_400_000
|
|
recordMessage(days, assistantMessage({ time: { created: old } }))
|
|
recordMessage(days, assistantMessage())
|
|
pruneUsage(days, 90, NOW)
|
|
expect(Object.keys(days)).toEqual([dayKey(NOW)])
|
|
})
|
|
})
|
|
|
|
describe("serialization round-trip", () => {
|
|
it("preserves buckets", () => {
|
|
const days: UsageDays = {}
|
|
recordMessage(days, assistantMessage())
|
|
addCreditsSpent(days, NOW, 0.07)
|
|
const restored = parseUsageDays(serializeUsage(days))
|
|
expect(dayTotals(restored, NOW).creditsSpent).toBeCloseTo(0.07)
|
|
expect(dayTotals(restored, NOW).byModel[0]?.model).toBe("glm-5.3-flash")
|
|
})
|
|
|
|
it("tolerates malformed payloads", () => {
|
|
expect(parseUsageDays(undefined)).toEqual({})
|
|
expect(parseUsageDays("nope")).toEqual({})
|
|
expect(parseUsageDays({ version: 2, days: [] })).toEqual({})
|
|
expect(parseUsageDays({ version: 1, days: [{ date: "bad" }] })).toEqual({})
|
|
})
|
|
})
|