Skip to content

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.

10.9 KB
Raw Blame
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";
import { parseRateTable, priceUsage } from "./usagePricing.ts";

it.layer(layer)("BotUsageLedger", (it) => {
  it.effect("reconciles progressive reports without counting reasoning twice", () =>
    Effect.gen(function* () {
      const ledger = yield* BotUsageLedger;
      const botId = BotId.make("bot-progressive");
      yield* ledger.reserve(reserveInput("progressive", { botId }));
      const turnId = TurnId.make("turn-progressive");

      yield* ledger.settleForTurn({
        botId,
        threadId: ThreadId.make("thread-1"),
        turnId,
        state: "reported",
        inputTokens: 100,
        outputTokens: 20,
        reasoningTokens: 10,
        settledAt: "2026-08-30T20:01:00.000Z",
      });
      yield* ledger.settleForTurn({
        botId,
        threadId: ThreadId.make("thread-1"),
        turnId,
        state: "reported",
        inputTokens: 150,
        outputTokens: 30,
        reasoningTokens: 15,
        settledAt: "2026-08-30T20:02:00.000Z",
      });
      yield* ledger.settleForTurn({
        botId,
        threadId: ThreadId.make("thread-1"),
        turnId,
        state: "reported",
        inputTokens: 150,
        outputTokens: 30,
        reasoningTokens: 15,
        settledAt: "2026-08-30T20:03:00.000Z",
      });

      const inFlight = yield* ledger.summarize(botId);
      assert.equal(inFlight.consumedTokens, 180);
      assert.equal(inFlight.reservedTokens, 820);
      yield* ledger.finalizeForTurn({
        botId,
        threadId: ThreadId.make("thread-1"),
        turnId,
        settledAt: "2026-08-30T20:04:00.000Z",
      });
      const summary = yield* ledger.summarize(botId);
      assert.equal(summary.consumedTokens, 180);
      assert.equal(summary.reservedTokens, 0);
      assert.equal(summary.entries[0]?.reasoningTokens, 15);
    }),
  );

  it.effect("records tool and routine writers and prices their tokens", () =>
    Effect.gen(function* () {
      const ledger = yield* BotUsageLedger;
      const botId = BotId.make("bot-tool-routine");

      const tool = yield* ledger.reserve(
        reserveInput("tool-entry", {
          botId,
          category: "tool",
          maximumTokens: 100,
        }),
      );

      yield* ledger.settle({
        reservationId: tool.reservationId,
        state: "reported",
        inputTokens: 20,
        outputTokens: 20,
        reasoningTokens: null,
        settledAt: "2026-08-30T20:01:00.000Z",
      });
      yield* ledger.recordMeasurement({
        reservationId: AkeruUsageReservationId.make("routine-entry"),
        sourceKey: "routine:run-1",
        botId,
        threadId: ThreadId.make("thread-1"),
        turnId: null,
        category: "routine",
        inputTokens: 10,
        outputTokens: 10,
        reasoningTokens: null,
        provider: ProviderDriverKind.make("codex"),
        model: "gpt-5.6-sol",
        createdAt: "2026-08-30T20:02:00.000Z",
      });
      const summary = yield* ledger.summarize(botId);
      assert.deepEqual(summary.entries.map((entry) => entry.category).sort(), ["routine", "tool"]);
      assert.equal(summary.consumedTokens, 60);

      const cost = priceUsage(
        parseRateTable({ "gpt-5.6-sol": { input_cost_per_token: 1, output_cost_per_token: 2 } }),
        "gpt-5.6-sol",
        {
          uncachedInputTokens: 30,
          cachedInputTokens: 0,
          cacheCreationTokens: 0,
          outputTokens: 30,
          reasoningTokens: 0,
        },
        null,
      );

      assert.equal(cost.costUsd, 90);
    }),
  );

  it.effect("charges one OM reservation and reports Observer and Reflector separately", () =>
    Effect.gen(function* () {
      const ledger = yield* BotUsageLedger;
      const botId = BotId.make("bot-composite-om");
      const threadId = ThreadId.make("thread-composite-om");
      const turnId = TurnId.make("turn-composite-om");

      const observer = yield* ledger.reserve(
        reserveInput("observer-composite", {
          sourceKey: "observer:turn-composite-om",
          botId,
          threadId,
          turnId,
          category: "observer",
          maximumTokens: 32_000,
        }),
      );

      yield* ledger.settle({
        reservationId: observer.reservationId,
        state: "reported",
        inputTokens: 100,
        outputTokens: 50,
        reasoningTokens: null,
        settledAt: "2026-08-30T20:01:00.000Z",
      });
      yield* ledger.recordMeasurement({
        reservationId: AkeruUsageReservationId.make("reflector-composite"),
        sourceKey: "reflector:turn-composite-om",
        botId,
        threadId,
        turnId,
        category: "reflector",
        inputTokens: 20,
        outputTokens: 10,
        reasoningTokens: null,
        provider: ProviderDriverKind.make("codex"),
        model: "gpt-5.6-sol",
        includedInReservation: true,
        createdAt: "2026-08-30T20:01:00.000Z",
      });

      const summary = yield* ledger.summarize(botId);
      assert.equal(summary.consumedTokens, 150);
      assert.equal(summary.reservedTokens, 0);
      assert.deepEqual(summary.measurements, {
        input: { tokens: 0, unavailableEntries: 0 },
        output: { tokens: 0, unavailableEntries: 0 },
        observer: { tokens: 120, unavailableEntries: 0 },
        reflector: { tokens: 30, unavailableEntries: 0 },
      });
    }),
  );

  for (const provider of ["kimi", "opencodeGo"] as const) {
    it.effect(`records observer and reflector rows for the ${provider} driver`, () =>
      Effect.gen(function* () {
        const ledger = yield* BotUsageLedger;
        const botId = BotId.make(`bot-${provider}-om`);
        const threadId = ThreadId.make(`thread-${provider}-om`);
        const turnId = TurnId.make(`turn-${provider}-om`);
        const model = provider === "kimi" ? "k3-256k" : "opencode-go/gpt-5.6";

        const observer = yield* ledger.reserve(
          reserveInput(`observer-${provider}`, {
            sourceKey: `observer:${turnId}`,
            botId,
            threadId,
            turnId,
            category: "observer",
            provider: ProviderDriverKind.make(provider),
            model,
            maximumTokens: 32_000,
          }),
        );

        yield* ledger.settle({
          reservationId: observer.reservationId,
          state: "reported",
          inputTokens: 60,
          outputTokens: 20,
          reasoningTokens: null,
          settledAt: "2026-08-30T20:01:00.000Z",
        });
        yield* ledger.recordMeasurement({
          reservationId: AkeruUsageReservationId.make(`reflector-${provider}`),
          sourceKey: `reflector:${turnId}`,
          botId,
          threadId,
          turnId,
          category: "reflector",
          inputTokens: 15,
          outputTokens: 5,
          reasoningTokens: null,
          provider: ProviderDriverKind.make(provider),
          model,
          includedInReservation: true,
          createdAt: "2026-08-30T20:01:00.000Z",
        });

        const summary = yield* ledger.summarize(botId);
        assert.equal(summary.consumedTokens, 80);
        // The reflector measurement is billed inside the observer reservation,
        // so observer tokens net out the reflector share.
        assert.equal(summary.measurements.observer.tokens, 60);
        assert.equal(summary.measurements.reflector.tokens, 20);
        assert.deepEqual(
          summary.entries.map((entry) => [entry.category, String(entry.provider)]).sort(),
          [
            ["observer", provider],
            ["reflector", provider],
          ],
        );
      }),
    );
  }

  it.effect("prices all ledger rows while keeping the visible history bounded", () =>
    Effect.gen(function* () {
      const ledger = yield* BotUsageLedger;
      const botId = BotId.make("bot-lifetime-cost");

      for (let index = 0; index < 201; index++) {
        yield* ledger.recordMeasurement({
          reservationId: AkeruUsageReservationId.make(`measurement-${index}`),
          sourceKey: `measurement-${index}`,
          botId,
          threadId: null,
          turnId: null,
          category: "tool",
          inputTokens: 10,
          outputTokens: 5,
          reasoningTokens: null,
          provider: ProviderDriverKind.make("codex"),
          model: "gpt-5.6-sol",
          createdAt: "2026-08-30T20:00:00.000Z",
        });
      }

      yield* ledger.recordMeasurement({
        reservationId: AkeruUsageReservationId.make("zero-unpriced"),
        sourceKey: "zero-unpriced",
        botId,
        threadId: null,
        turnId: null,
        category: "tool",
        inputTokens: 0,
        outputTokens: 0,
        reasoningTokens: null,
        provider: null,
        model: null,
        createdAt: "2026-08-30T20:00:00.000Z",
      });
      const summary = yield* ledger.summarize(botId);
      const pricing = yield* ledger.pricingTotals(botId);
      assert.equal(summary.entries.length, 200);
      assert.equal(pricing.complete, true);
      assert.deepEqual(pricing.models, [
        {
          model: "gpt-5.6-sol",
          inputTokens: 2010,
          cachedInputTokens: 0,
          cacheCreationTokens: 0,
          outputTokens: 1005,
          reasoningTokens: 0,
        },
      ]);
      yield* ledger.recordMeasurement({
        reservationId: AkeruUsageReservationId.make("unknown-priced"),
        sourceKey: "unknown-priced",
        botId,
        threadId: null,
        turnId: null,
        category: "tool",
        inputTokens: 10,
        outputTokens: 0,
        reasoningTokens: null,
        provider: null,
        model: null,
        createdAt: "2026-08-30T20:00:00.000Z",
      });
      assert.equal((yield* ledger.pricingTotals(botId)).complete, false);
    }),
  );

  it.effect("keeps cache token categories for model pricing", () =>
    Effect.gen(function* () {
      const ledger = yield* BotUsageLedger;
      const botId = BotId.make("bot-cached-input");
      const reservation = yield* ledger.reserve(reserveInput("cached-input", { botId }));
      yield* ledger.settle({
        reservationId: reservation.reservationId,
        state: "reported",
        inputTokens: 100,
        cachedInputTokens: 80,
        cacheCreationTokens: 10,
        outputTokens: 5,
        reasoningTokens: null,
        settledAt: "2026-08-30T20:01:00.000Z",
      });
      const summary = yield* ledger.summarize(botId);
      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,
        },
      ]);
    }),
  );
});