Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import { layer, reserveInput } from "./testUtils/botUsageLedger.ts";
import { assert, it } from "@effect/vitest";
import {
AkeruUsageReservationId,
BotId,
ProviderDriverKind,
ThreadId,
TurnId,
} from "@akeru/contracts";
import * as Effect from "effect/Effect";
import { BotUsageLedger } from "./BotUsageLedger.ts";
it.layer(layer)("BotUsageLedger", (it) => {
it.effect("claims a runtime turn before a late command binding", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const reservation = yield* ledger.reserve(
reserveInput("runtime-first", { botId: BotId.make("bot-runtime-first") }),
);
const turnId = TurnId.make("turn-runtime-first");
const claimed = yield* ledger.settleForTurn({
botId: BotId.make("bot-runtime-first"),
threadId: ThreadId.make("thread-1"),
turnId,
state: "reported",
inputTokens: 40,
outputTokens: 2,
reasoningTokens: null,
settledAt: "2026-08-30T20:01:00.000Z",
});
assert.equal(claimed[0]?.turnId, turnId);
const late = yield* ledger.bindTurn({ reservationId: reservation.reservationId, turnId });
assert.equal(late.turnId, turnId);
const conflict = yield* ledger
.bindTurn({
reservationId: reservation.reservationId,
turnId: TurnId.make("another-turn"),
})
.pipe(Effect.exit);
assert.equal(conflict._tag, "Failure");
}),
);
it.effect("isolates source keys and balances by bot", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const sourceKey = "turn-start:shared-event-id";
const firstBotId = BotId.make("bot-isolation-a");
const secondBotId = BotId.make("bot-isolation-b");
yield* ledger.reserve(
reserveInput("bot-a", {
sourceKey,
botId: firstBotId,
maximumTokens: 60,
}),
);
yield* ledger.reserve(
reserveInput("bot-b", {
sourceKey,
botId: secondBotId,
maximumTokens: 60,
}),
);
const first = yield* ledger.summarize(firstBotId);
const second = yield* ledger.summarize(secondBotId);
assert.equal(first.entries.length, 1);
assert.equal(second.entries.length, 1);
assert.equal(first.reservedTokens, 60);
assert.equal(second.reservedTokens, 60);
}),
);
it.effect("charges the reservation when provider usage is unavailable", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const botId = BotId.make("bot-unavailable");
const reservation = yield* ledger.reserve(
reserveInput("unavailable", { botId, maximumTokens: 500 }),
);
yield* ledger.settle({
reservationId: reservation.reservationId,
state: "unavailable",
reason: "Provider completed without token usage.",
settledAt: "2026-08-30T20:01:00.000Z",
});
yield* ledger.settle({
reservationId: reservation.reservationId,
state: "unavailable",
reason: "Provider completed without token usage.",
settledAt: "2026-08-30T20:02:00.000Z",
});
const summary = yield* ledger.summarize(botId);
assert.equal(summary.consumedTokens, 500);
assert.equal(summary.reservedTokens, 0);
assert.equal(
summary.entries[0]?.unavailableReason,
"Provider completed without token usage.",
);
}),
);
it.effect("releases a cancelled turn without consuming its cap", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const botId = BotId.make("bot-cancelled");
yield* ledger.reserve(reserveInput("cancelled", { botId, maximumTokens: 500 }));
yield* ledger.finalizeForTurn({
botId,
threadId: ThreadId.make("thread-1"),
turnId: TurnId.make("turn-cancelled"),
settledAt: "2026-08-30T20:01:00.000Z",
cancelled: true,
});
const summary = yield* ledger.summarize(botId);
assert.equal(summary.consumedTokens, 0);
assert.equal(summary.reservedTokens, 0);
assert.equal(summary.entries[0]?.state, "released");
}),
);
it.effect("a late cancellation cannot release the next turn's reservation", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const botId = BotId.make("bot-late-cancellation");
const threadId = ThreadId.make("thread-1");
const oldTurnId = TurnId.make("turn-old");
yield* ledger.reserve(reserveInput("old-turn", { botId, threadId, maximumTokens: 500 }));
yield* ledger.finalizeForTurn({
botId,
threadId,
turnId: oldTurnId,
settledAt: "2026-08-30T20:01:00.000Z",
cancelled: true,
});
yield* ledger.reserve(reserveInput("new-turn", { botId, threadId, maximumTokens: 500 }));
yield* ledger.finalizeForTurn({
botId,
threadId,
turnId: oldTurnId,
settledAt: "2026-08-30T20:02:00.000Z",
cancelled: true,
});
const summary = yield* ledger.summarize(botId);
assert.equal(summary.reservedTokens, 500);
assert.equal(
summary.entries.find((entry) => entry.sourceKey === "turn-start:new-turn")?.state,
"reserved",
);
assert.equal(
summary.entries.find((entry) => entry.sourceKey === "turn-start:old-turn")?.turnId,
oldTurnId,
);
}),
);
it.effect("preserves reported usage when a turn is cancelled", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const botId = BotId.make("bot-cancelled-after-report");
const turnId = TurnId.make("turn-cancelled-after-report");
yield* ledger.reserve(reserveInput("cancelled-after-report", { botId, maximumTokens: 500 }));
yield* ledger.settleForTurn({
botId,
threadId: ThreadId.make("thread-1"),
turnId,
state: "reported",
inputTokens: 120,
outputTokens: 30,
reasoningTokens: 10,
settledAt: "2026-08-30T20:01:00.000Z",
});
yield* ledger.finalizeForTurn({
botId,
threadId: ThreadId.make("thread-1"),
turnId,
settledAt: "2026-08-30T20:02:00.000Z",
cancelled: true,
});
const summary = yield* ledger.summarize(botId);
assert.equal(summary.consumedTokens, 150);
assert.equal(summary.reservedTokens, 0);
assert.equal(summary.entries[0]?.state, "reported");
assert.equal(summary.entries[0]?.inputTokens, 120);
assert.equal(summary.entries[0]?.outputTokens, 30);
}),
);
it.effect("records reported overage as enforcement truth", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const botId = BotId.make("bot-reported-overage");
const reservation = yield* ledger.reserve(
reserveInput("reported-overage", { botId, maximumTokens: 100 }),
);
yield* ledger.settle({
reservationId: reservation.reservationId,
state: "reported",
inputTokens: 120,
outputTokens: 30,
reasoningTokens: 10,
settledAt: "2026-08-30T20:01:00.000Z",
});
const summary = yield* ledger.summarize(botId);
assert.equal(summary.consumedTokens, 150);
assert.equal(summary.measurements.input.tokens, 120);
assert.equal(summary.measurements.output.tokens, 30);
}),
);
it.effect("charges a standalone reported measurement once", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const botId = BotId.make("bot-standalone-measurement");
const input = {
reservationId: AkeruUsageReservationId.make("standalone-measurement"),
sourceKey: "tool:standalone-measurement",
botId,
threadId: ThreadId.make("thread-standalone-measurement"),
turnId: TurnId.make("turn-standalone-measurement"),
category: "tool" as const,
inputTokens: 20,
outputTokens: 10,
reasoningTokens: 5,
provider: ProviderDriverKind.make("codex"),
model: "gpt-5.6-sol",
createdAt: "2026-08-30T20:01:00.000Z",
};
yield* ledger.recordMeasurement(input);
yield* ledger.recordMeasurement(input);
const summary = yield* ledger.summarize(botId);
assert.equal(summary.consumedTokens, 30);
assert.equal(summary.entries.length, 1);
}),
);
it.effect("keeps unavailable OM work out of ordinary input and output counts", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const botId = BotId.make("bot-unavailable-categories");
for (const [category, reservationId] of [
["turn", "unavailable-turn"],
["observer", "unavailable-observer"],
["reflector", "unavailable-reflector"],
] as const) {
const reservation = yield* ledger.reserve(
reserveInput(reservationId, {
botId,
sourceKey: reservationId,
category,
maximumTokens: 100,
}),
);
yield* ledger.settle({
reservationId: reservation.reservationId,
state: "unavailable",
reason: "Provider usage was unavailable.",
settledAt: "2026-08-30T20:01:00.000Z",
});
}
const summary = yield* ledger.summarize(botId);
assert.equal(summary.measurements.input.unavailableEntries, 1);
assert.equal(summary.measurements.output.unavailableEntries, 1);
assert.equal(summary.measurements.observer.unavailableEntries, 1);
assert.equal(summary.measurements.reflector.unavailableEntries, 1);
}),
);
it.effect("meters delegated work against the performing bot", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const childId = BotId.make("bot-research");
const parentId = BotId.make("bot-chief");
const reservation = yield* ledger.reserve(
reserveInput("delegate-child", {
botId: childId,
sourceKey: "delegate:chief:research",
category: "delegated",
maximumTokens: 200,
}),
);
yield* ledger.settle({
reservationId: reservation.reservationId,
state: "reported",
inputTokens: 80,
outputTokens: 40,
reasoningTokens: 0,
settledAt: "2026-08-30T20:01:00.000Z",
});
const child = yield* ledger.summarize(childId);
const parent = yield* ledger.summarize(parentId);
assert.equal(child.measurements.input.tokens, 80);
assert.equal(child.measurements.output.tokens, 40);
assert.equal(child.consumedTokens, 120);
assert.equal(parent.consumedTokens, 0);
}),
);
it.effect("accepts a later cache breakdown without charging the same tokens twice", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const botId = BotId.make("bot-late-cache-breakdown");
const reservation = yield* ledger.reserve(reserveInput("late-cache", { botId }));
const reported = {
reservationId: reservation.reservationId,
state: "reported" as const,
inputTokens: 100,
outputTokens: 5,
reasoningTokens: null,
settledAt: "2026-08-30T20:01:00.000Z",
};
yield* ledger.settle(reported);
yield* ledger.settle({
...reported,
cachedInputTokens: 80,
cacheCreationTokens: 10,
settledAt: "2026-08-30T20:02:00.000Z",
});
yield* ledger.settle({ ...reported, settledAt: "2026-08-30T20:03:00.000Z" });
const summary = yield* ledger.summarize(botId);
assert.equal(summary.consumedTokens, 105);
assert.equal(summary.entries[0]?.cachedInputTokens, 80);
assert.equal(summary.entries[0]?.cacheCreationTokens, 10);
assert.deepEqual((yield* ledger.pricingTotals(botId)).models, [
{
model: "gpt-5.6-sol",
inputTokens: 100,
cachedInputTokens: 80,
cacheCreationTokens: 10,
outputTokens: 5,
reasoningTokens: 0,
},
]);
}),
);
it.effect("accepts a newer corrected cache mix and ignores an older replay", () =>
Effect.gen(function* () {
const ledger = yield* BotUsageLedger;
const botId = BotId.make("bot-corrected-cache-breakdown");
const reservation = yield* ledger.reserve(reserveInput("corrected-cache", { botId }));
const reported = {
reservationId: reservation.reservationId,
state: "reported" as const,
inputTokens: 100,
outputTokens: 5,
reasoningTokens: null,
};
yield* ledger.settle({
...reported,
cachedInputTokens: 80,
cacheCreationTokens: 10,
settledAt: "2026-08-30T20:01:00.000Z",
});
yield* ledger.settle({
...reported,
cachedInputTokens: 70,
cacheCreationTokens: 20,
settledAt: "2026-08-30T20:03:00.000Z",
});
yield* ledger.settle({
...reported,
cachedInputTokens: 80,
cacheCreationTokens: 10,
settledAt: "2026-08-30T20:02:00.000Z",
});
yield* ledger.settle({ ...reported, settledAt: "2026-08-30T20:04:00.000Z" });
const summary = yield* ledger.summarize(botId);
assert.equal(summary.consumedTokens, 105);
assert.equal(summary.entries[0]?.cachedInputTokens, 70);
assert.equal(summary.entries[0]?.cacheCreationTokens, 20);
assert.deepEqual((yield* ledger.pricingTotals(botId)).models, [
{
model: "gpt-5.6-sol",
inputTokens: 100,
cachedInputTokens: 70,
cacheCreationTokens: 20,
outputTokens: 5,
reasoningTokens: 0,
},
]);
}),
);
});