Show real credit spend and a per-model breakdown under the balance: - ``src/usage.ts`` (new, pure): idempotent day buckets keyed by message id, day/month totals, retention pruning, validated KV serialization. - Real spend = delta of ``x-credits-remaining`` between two free probes (top-ups are not counted as spend), covering every client of the key. - Per-model detail = reconciliation of local GreenPT assistant messages (tokens + estimated cost, marked ``~``), re-run on every refresh and on ``session.idle``; last 10 sessions backfilled at startup. - Buckets persisted in the plugin KV store (90-day window) with new options ``trackUsage``, ``usageWindowDays``, ``usageBackfill`` and a ``greenpt.usage.reset`` command.
155 lines
4.6 KiB
TypeScript
155 lines
4.6 KiB
TypeScript
import { describe, expect, it, vi } from "vitest"
|
|
import { createBalanceStore, type BalanceOptions } from "../src/store"
|
|
import { nativeFetch } from "../src/balance"
|
|
import { serializeUsage, type UsageDays } from "../src/usage"
|
|
|
|
const NOW = new Date(2026, 9, 19, 15, 0, 0).getTime()
|
|
const DAY = "2026-10-19"
|
|
|
|
type FakeMessage = Record<string, unknown>
|
|
|
|
function makeApi() {
|
|
const kvData = new Map<string, unknown>()
|
|
const messages = new Map<string, FakeMessage[]>()
|
|
const handlers = new Map<string, Array<(event: unknown) => void>>()
|
|
const api = {
|
|
event: {
|
|
on: (type: string, handler: (event: unknown) => void) => {
|
|
const list = handlers.get(type) ?? []
|
|
list.push(handler)
|
|
handlers.set(type, list)
|
|
return () => {
|
|
handlers.set(
|
|
type,
|
|
(handlers.get(type) ?? []).filter((item) => item !== handler),
|
|
)
|
|
}
|
|
},
|
|
},
|
|
kv: {
|
|
ready: true,
|
|
get: (key: string, fallback?: unknown) => (kvData.has(key) ? kvData.get(key) : fallback),
|
|
set: (key: string, value: unknown) => {
|
|
kvData.set(key, value)
|
|
},
|
|
},
|
|
state: {
|
|
path: { state: "/tmp/fake-state" },
|
|
session: {
|
|
messages: (sessionID: string) => messages.get(sessionID) ?? [],
|
|
},
|
|
},
|
|
client: {
|
|
session: {
|
|
list: async () => ({ data: [] }),
|
|
messages: async () => ({ data: [] }),
|
|
},
|
|
},
|
|
emit(type: string, event: unknown) {
|
|
for (const handler of handlers.get(type) ?? []) handler(event)
|
|
},
|
|
}
|
|
return { api, kvData, messages }
|
|
}
|
|
|
|
function balanceResponse(credits: number) {
|
|
return new Response(null, { status: 400, headers: { "x-credits-remaining": String(credits) } })
|
|
}
|
|
|
|
function fetchSequence(credits: number[]) {
|
|
let index = 0
|
|
return vi.fn(() => {
|
|
const response = balanceResponse(credits[Math.min(index, credits.length - 1)] ?? 0)
|
|
index += 1
|
|
return Promise.resolve(response)
|
|
}) as unknown as typeof nativeFetch
|
|
}
|
|
|
|
function createTrackedStore(api: unknown, options: BalanceOptions = {}) {
|
|
return createBalanceStore(api as never, { apiKey: "test-key", ...options }, {}, fetchSequence([10]))
|
|
}
|
|
|
|
describe("usage tracking in the balance store", () => {
|
|
it("accumulates real credit spend from balance deltas", async () => {
|
|
const { api } = makeApi()
|
|
const store = createBalanceStore(
|
|
api as never,
|
|
{ apiKey: "test-key" },
|
|
{},
|
|
fetchSequence([10, 9.95, 9.9, 12]),
|
|
)
|
|
await store.refresh()
|
|
await store.refresh()
|
|
await store.refresh()
|
|
await store.refresh()
|
|
expect(store.usageDays()[DAY]?.creditsSpent).toBeCloseTo(0.1)
|
|
store.dispose()
|
|
})
|
|
|
|
it("reconciles per-model usage from tracked sessions on refresh", async () => {
|
|
const { api, messages } = makeApi()
|
|
const store = createTrackedStore(api)
|
|
messages.set("s1", [
|
|
{
|
|
id: "m1",
|
|
role: "assistant",
|
|
providerID: "greenpt",
|
|
modelID: "glm-5.3-flash",
|
|
cost: 0.02,
|
|
time: { created: NOW },
|
|
tokens: { input: 10, output: 5, reasoning: 0, cache: { read: 0, write: 0 } },
|
|
},
|
|
])
|
|
api.emit("session.idle", { properties: { sessionID: "s1" } })
|
|
await store.refresh()
|
|
await store.refresh()
|
|
expect(store.usageDays()[DAY]?.byModel["glm-5.3-flash"]?.cost).toBeCloseTo(0.02)
|
|
store.dispose()
|
|
})
|
|
|
|
it("persists buckets to the KV store and reloads them", async () => {
|
|
const { api, kvData } = makeApi()
|
|
const first = createBalanceStore(
|
|
api as never,
|
|
{ apiKey: "test-key" },
|
|
{},
|
|
fetchSequence([10, 9.9]),
|
|
)
|
|
await first.refresh()
|
|
await first.refresh()
|
|
expect(kvData.has("greenpt.usage.days")).toBe(true)
|
|
first.dispose()
|
|
|
|
const stored: UsageDays = { [DAY]: { date: DAY, creditsSpent: 0.5, byModel: {}, ids: [] } }
|
|
kvData.set("greenpt.usage.days", serializeUsage(stored))
|
|
const second = createTrackedStore(api)
|
|
expect(second.usageDays()[DAY]?.creditsSpent).toBeCloseTo(0.5)
|
|
second.dispose()
|
|
})
|
|
|
|
it("resetUsage clears buckets", async () => {
|
|
const { api } = makeApi()
|
|
const store = createTrackedStore(api)
|
|
await store.refresh()
|
|
await store.refresh()
|
|
store.resetUsage()
|
|
expect(Object.keys(store.usageDays()).length).toBe(0)
|
|
store.dispose()
|
|
})
|
|
|
|
it("skips tracking when disabled", async () => {
|
|
const { api, kvData } = makeApi()
|
|
const store = createBalanceStore(
|
|
api as never,
|
|
{ apiKey: "test-key", trackUsage: false },
|
|
{},
|
|
fetchSequence([10, 5]),
|
|
)
|
|
await store.refresh()
|
|
await store.refresh()
|
|
expect(Object.keys(store.usageDays()).length).toBe(0)
|
|
expect(kvData.has("greenpt.usage.days")).toBe(false)
|
|
store.dispose()
|
|
})
|
|
})
|