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.

6.5 KB
Raw Blame
import { reserveInput } from "./testUtils/botUsageLedger.ts";
import { assert, it } from "@effect/vitest";
import { BotId, ThreadId, TurnId } from "@akeru/contracts";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import { sqlitePersistenceLayer } from "../persistence/Layers/Sqlite.ts";
import { BotUsageLedger, BotUsageLedgerLive } from "./BotUsageLedger.ts";
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import * as NodeServices from "@effect/platform-node/NodeServices";

it.effect("reconciles persisted reservations when the ledger restarts", () =>
  Effect.gen(function* () {
    const directory = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-usage-restart-"));
    const dbPath = NodePath.join(directory, "state.sqlite");

    const restartedLayer = () =>
      BotUsageLedgerLive.pipe(
        Layer.provideMerge(sqlitePersistenceLayer(dbPath).pipe(Layer.provide(NodeServices.layer))),
      );

    const botId = BotId.make("bot-restart-usage");
    const threadId = ThreadId.make("thread-restart-usage");
    yield* Effect.gen(function* () {
      const ledger = yield* BotUsageLedger;
      yield* ledger.reserve(
        reserveInput("unbound-before-restart", {
          botId,
          threadId,
          maximumTokens: 100,
        }),
      );
      yield* ledger.reserve(
        reserveInput("bound-before-restart", {
          botId,
          threadId,
          turnId: TurnId.make("turn-interrupted"),
          maximumTokens: 200,
        }),
      );
      yield* ledger.reserve(
        reserveInput("reported-before-restart", {
          botId,
          threadId,
          turnId: TurnId.make("turn-reported"),
          maximumTokens: 300,
        }),
      );

      const { maximumTokens: _maximumTokens, ...toolStart } = reserveInput("tool-before-restart", {
        botId,
        threadId,
        turnId: TurnId.make("turn-interrupted"),
        category: "tool",
      });

      const tool = yield* ledger.recordStart(toolStart);
      assert.equal(tool.state, "reserved");
      assert.equal(tool.reservedTokens, 0);
      yield* ledger.settleForTurn({
        botId,
        threadId,
        turnId: TurnId.make("turn-reported"),
        state: "reported",
        inputTokens: 40,
        outputTokens: 10,
        reasoningTokens: 20,
        settledAt: "2026-08-30T20:01:00.000Z",
      });
    }).pipe(Effect.provide(restartedLayer()));

    const { afterRestart, afterLateReport } = yield* Effect.gen(function* () {
      const ledger = yield* BotUsageLedger;
      const afterRestart = yield* ledger.summarize(botId);
      yield* ledger.settleForTurn({
        botId,
        threadId,
        turnId: TurnId.make("turn-reported"),
        state: "reported",
        inputTokens: 60,
        outputTokens: 20,
        reasoningTokens: 25,
        settledAt: "2026-08-30T20:02:00.000Z",
      });
      yield* ledger.finalizeForTurn({
        botId,
        threadId,
        turnId: TurnId.make("turn-reported"),
        settledAt: "2026-08-30T20:03:00.000Z",
      });

      return { afterRestart, afterLateReport: yield* ledger.summarize(botId) };
    }).pipe(Effect.provide(restartedLayer()));

    assert.equal(afterRestart.consumedTokens, 250);
    assert.equal(afterRestart.reservedTokens, 0);
    assert.equal(
      afterRestart.entries.find((entry) => entry.sourceKey.includes("unbound-before-restart"))
        ?.state,
      "released",
    );
    assert.equal(
      afterRestart.entries.find((entry) => entry.sourceKey === "turn-start:bound-before-restart")
        ?.state,
      "unavailable",
    );
    assert.equal(
      afterRestart.entries.find((entry) => entry.sourceKey.includes("reported-before-restart"))
        ?.state,
      "reported",
    );
    assert.equal(
      afterRestart.entries.find((entry) => entry.sourceKey.includes("tool-before-restart"))?.state,
      "unavailable",
    );
    assert.equal(afterLateReport.consumedTokens, 280);
    assert.equal(afterLateReport.reservedTokens, 0);
    NodeFS.rmSync(directory, { recursive: true, force: true });
  }).pipe(Effect.provide(NodeServices.layer), Effect.orDie),
);

it.effect("keeps pricing complete when a restart interrupts a tool call", () =>
  Effect.gen(function* () {
    const directory = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-usage-tool-"));

    const restartedLayer = () =>
      BotUsageLedgerLive.pipe(
        Layer.provideMerge(
          sqlitePersistenceLayer(NodePath.join(directory, "state.sqlite")).pipe(
            Layer.provide(NodeServices.layer),
          ),
        ),
      );

    const botId = BotId.make("bot-interrupted-tool");
    const threadId = ThreadId.make("thread-interrupted-tool");
    const turnId = TurnId.make("turn-interrupted-tool");
    yield* Effect.gen(function* () {
      const ledger = yield* BotUsageLedger;
      yield* ledger.reserve(reserveInput("priced-turn", { botId, threadId, turnId }));
      yield* ledger.settleForTurn({
        botId,
        threadId,
        turnId,
        state: "reported",
        inputTokens: 100,
        outputTokens: 20,
        reasoningTokens: null,
        settledAt: "2026-08-30T20:01:00.000Z",
      });
      yield* ledger.finalizeForTurn({
        botId,
        threadId,
        turnId,
        settledAt: "2026-08-30T20:02:00.000Z",
      });

      const { maximumTokens: _maximumTokens, ...toolStart } = reserveInput("interrupted-tool", {
        botId,
        threadId,
        turnId,
        category: "tool",
      });

      yield* ledger.recordStart(toolStart);
    }).pipe(Effect.provide(restartedLayer()));

    const { summary, pricing } = yield* Effect.gen(function* () {
      const ledger = yield* BotUsageLedger;

      return {
        summary: yield* ledger.summarize(botId),
        pricing: yield* ledger.pricingTotals(botId),
      };
    }).pipe(Effect.provide(restartedLayer()));

    const tool = summary.entries.find((entry) => entry.sourceKey.includes("interrupted-tool"));
    assert.equal(tool?.state, "unavailable");
    assert.equal(tool?.unavailableReason, "Provider work was interrupted by a server restart.");
    assert.equal(summary.measurements.input.unavailableEntries, 0);
    assert.equal(summary.measurements.output.unavailableEntries, 0);
    assert.equal(pricing.complete, true);
    assert.deepEqual(
      pricing.models.map((model) => [model.model, model.inputTokens, model.outputTokens]),
      [["gpt-5.6-sol", 100, 20]],
    );
    NodeFS.rmSync(directory, { recursive: true, force: true });
  }).pipe(Effect.provide(NodeServices.layer), Effect.orDie),
);