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 {
projectionQueryFixture,
providerRuntimeContext,
} from "./test-support/projectionFixtures.ts";
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import {
AkeruMemoryTenantId,
AkeruMemoryUserId,
BotId,
EventId,
GroupId,
ProviderDriverKind,
ProjectId,
ThreadId,
TurnId,
type ProviderRuntimeEvent,
} from "@akeru/contracts";
import { it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Stream from "effect/Stream";
import { assert, describe, expect, vi } from "vite-plus/test";
import { BotMemoryStore } from "../../memory/BotMemory.ts";
import { createBotMemoryToolHandler } from "../../memory/BotMemoryToolHandlers.ts";
import * as McpMemoryToolSession from "../../mcp/McpMemoryToolSession.ts";
import { AgentController } from "../Services/AgentController.ts";
import * as ProjectionSnapshotQuery from "../../orchestration/Services/ProjectionSnapshotQuery.ts";
import { PersistenceSqlError } from "../../persistence/Errors.ts";
import {
codexThreadId,
claudeThreadId,
codexInstanceId,
openCodeInstanceId,
codexSelection,
} from "./test-support/agentControllerFixtures.ts";
import {
completeLegacyTurnWithMemoryReview,
makeMemoryOnlyCredentialOptions,
usageLedgerFixture,
} from "./test-support/agentControllerMemory.ts";
import {
makeBridge,
provideController,
resolveCodex,
} from "./test-support/agentControllerLayers.ts";
import { mastraHarnessFixture } from "./test-support/agentControllerHarness.ts";
describe("AgentControllerLive", () => {
it.effect("releases a Mastra cadence reservation when admission is interrupted", () => {
vi.useFakeTimers();
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
const memoryDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-review-interrupt-"));
const botMemoryStore = new BotMemoryStore(memoryDir);
const botId = BotId.make("bot-review-interrupt");
const renew = vi.spyOn(botMemoryStore, "renewReviewClaim");
const reservationReached = Promise.withResolvers<void>();
const reserve = botMemoryStore.reserveReviewCadence.bind(botMemoryStore);
vi.spyOn(botMemoryStore, "reserveReviewCadence").mockImplementation(async (reservedBotId) => {
const reservation = await reserve(reservedBotId);
reservationReached.resolve();
return reservation;
});
return provideController(
Effect.gen(function* () {
for (let prompt = 1; prompt <= 10; prompt += 1) {
const reservation = yield* Effect.promise(() =>
botMemoryStore.reserveReviewCadence(botId),
);
yield* Effect.promise(() => botMemoryStore.settleReviewCadence(reservation, true));
}
const controller = yield* AgentController;
yield* resolveCodex(controller);
yield* controller.startSession(codexThreadId, {
threadId: codexThreadId,
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
modelSelection: codexSelection,
runtimeMode: "full-access",
memoryAccess: {
tenantId: AkeruMemoryTenantId.make("local"),
userId: AkeruMemoryUserId.make("owner"),
threadId: codexThreadId,
projectId: ProjectId.make("project-review-interrupt"),
workspaceRoot: "/workspace/review-interrupt",
botId,
groupId: null,
respondingBotId: botId,
groupMemberBotIds: [],
},
});
yield* controller.sendTurn({ threadId: codexThreadId, input: "Interrupt admission." });
yield* Effect.promise(() => reservationReached.promise);
yield* controller.interruptTurn({ threadId: codexThreadId });
yield* Effect.promise(() => vi.advanceTimersByTimeAsync(60_000));
expect(renew).not.toHaveBeenCalled();
const anotherStore = new BotMemoryStore(memoryDir);
const next = yield* Effect.promise(() => anotherStore.reserveReviewCadence(botId));
yield* Effect.promise(() => anotherStore.settleReviewCadence(next, false));
}),
bridge.service,
mastra.factory,
undefined,
undefined,
undefined,
{ botMemoryStore },
).pipe(
Effect.ensuring(
Effect.sync(() => {
vi.useRealTimers();
NodeFS.rmSync(memoryDir, { recursive: true, force: true });
}),
),
);
});
});
describe("AgentControllerLive", () => {
it.effect.each([0, 1, 2])(
"settles a Mastra review only after one successful memory call (count: %s)",
(successfulMemoryCalls) => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
const memoryDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-mastra-review-"));
const botMemoryStore = new BotMemoryStore(memoryDir);
const botId = BotId.make("bot-mastra-review");
const access = {
tenantId: AkeruMemoryTenantId.make("local"),
userId: AkeruMemoryUserId.make("owner"),
threadId: codexThreadId,
projectId: ProjectId.make("project-mastra-review"),
workspaceRoot: "/workspace/mastra-review",
botId,
groupId: null,
respondingBotId: botId,
groupMemberBotIds: [],
} as const;
return provideController(
Effect.gen(function* () {
for (let prompt = 1; prompt <= 10; prompt += 1) {
const reservation = yield* Effect.promise(() =>
botMemoryStore.reserveReviewCadence(botId),
);
yield* Effect.promise(() => botMemoryStore.settleReviewCadence(reservation, true));
}
const acceptedRecorded = Promise.withResolvers<void>();
const settleReviewClaim = botMemoryStore.settleReviewClaim.bind(botMemoryStore);
vi.spyOn(botMemoryStore, "settleReviewClaim").mockImplementation(async (...args) => {
const result = await settleReviewClaim(...args);
acceptedRecorded.resolve();
return result;
});
const controller = yield* AgentController;
yield* resolveCodex(controller);
yield* controller.startSession(codexThreadId, {
threadId: codexThreadId,
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
modelSelection: codexSelection,
runtimeMode: "full-access",
memoryAccess: access,
});
yield* controller.sendTurn({ threadId: codexThreadId, input: "The tenth prompt" });
yield* Effect.promise(() => mastra.waitForSendMessageCount(1));
expect(mastra.session.state.set).toHaveBeenLastCalledWith(
expect.objectContaining({
persistentMemoryContext: expect.stringContaining("<automatic-memory-review>"),
}),
);
expect(mastra.session.state.set).toHaveBeenLastCalledWith(
expect.objectContaining({
persistentMemoryContext: expect.stringContaining(
"GROUP.md is not available in this chat",
),
}),
);
const runtime = mastra.harnessOptions[0]?.toolRuntime;
assert.isDefined(runtime);
for (let call = 0; call < successfulMemoryCalls; call += 1) {
yield* Effect.promise(() =>
runtime.execute({
threadId: String(codexThreadId),
toolId: "memory",
toolCallId: `automatic-review-no-op-${call}`,
input: { target: "user", operations: [] },
approvalMode: "require-grant",
}),
);
}
mastra.finishSend();
yield* Effect.promise(() => acceptedRecorded.promise);
assert.deepEqual(yield* Effect.promise(() => botMemoryStore.readReviewCadence(botId)), {
acceptedPromptCount: 11,
reviewedThroughPromptCount: successfulMemoryCalls === 1 ? 10 : 0,
dueOnNextAcceptedPrompt: successfulMemoryCalls !== 1,
});
}),
bridge.service,
mastra.factory,
undefined,
undefined,
undefined,
{ botMemoryStore },
).pipe(
Effect.ensuring(
Effect.sync(() => NodeFS.rmSync(memoryDir, { recursive: true, force: true })),
),
);
},
);
});
describe("AgentControllerLive", () => {
it.effect("stops renewing a Mastra review claim once the turn settles", () => {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "setInterval", "clearInterval"] });
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
const memoryDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-review-renewal-"));
const botMemoryStore = new BotMemoryStore(memoryDir);
const botId = BotId.make("bot-review-renewal");
const renew = vi.spyOn(botMemoryStore, "renewReviewClaim");
return provideController(
Effect.gen(function* () {
for (let prompt = 1; prompt <= 10; prompt += 1) {
const reservation = yield* Effect.promise(() =>
botMemoryStore.reserveReviewCadence(botId),
);
yield* Effect.promise(() => botMemoryStore.settleReviewCadence(reservation, true));
}
const settled = Promise.withResolvers<void>();
const settleReviewClaim = botMemoryStore.settleReviewClaim.bind(botMemoryStore);
vi.spyOn(botMemoryStore, "settleReviewClaim").mockImplementation(async (...args) => {
const result = await settleReviewClaim(...args);
settled.resolve();
return result;
});
const controller = yield* AgentController;
yield* resolveCodex(controller);
yield* controller.startSession(codexThreadId, {
threadId: codexThreadId,
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
modelSelection: codexSelection,
runtimeMode: "full-access",
memoryAccess: {
tenantId: AkeruMemoryTenantId.make("local"),
userId: AkeruMemoryUserId.make("owner"),
threadId: codexThreadId,
projectId: ProjectId.make("project-review-renewal"),
workspaceRoot: "/workspace/review-renewal",
botId,
groupId: null,
respondingBotId: botId,
groupMemberBotIds: [],
},
});
// Effect's scheduler and the lock retry also use timers, so pump fake
// time until the awaited receipt lands instead of advancing blindly.
const pumpUntil = async (receipt: Promise<void>) => {
let landed = false;
void receipt.then(() => {
landed = true;
});
for (;;) {
if (landed) break;
await vi.advanceTimersByTimeAsync(15);
}
};
const secondRenewal = Promise.withResolvers<void>();
renew.mockImplementation(async (...args) => {
const result = await BotMemoryStore.prototype.renewReviewClaim.apply(
botMemoryStore,
args,
);
if (renew.mock.calls.length >= 2) secondRenewal.resolve();
return result;
});
yield* controller.sendTurn({ threadId: codexThreadId, input: "Review this turn." });
yield* Effect.promise(() => pumpUntil(mastra.waitForSendMessageCount(1)));
// While the turn runs, the claim is renewed on its 20 second schedule.
yield* Effect.promise(() => pumpUntil(secondRenewal.promise));
mastra.finishSend();
yield* Effect.promise(() => pumpUntil(settled.promise));
const renewalsBeforeSettlement = renew.mock.calls.length;
yield* Effect.promise(() => vi.advanceTimersByTimeAsync(120_000));
expect(renew).toHaveBeenCalledTimes(renewalsBeforeSettlement);
}),
bridge.service,
mastra.factory,
undefined,
undefined,
undefined,
{ botMemoryStore },
).pipe(
Effect.ensuring(
Effect.sync(() => {
vi.useRealTimers();
NodeFS.rmSync(memoryDir, { recursive: true, force: true });
}),
),
);
});
});
describe("AgentControllerLive", () => {
it.effect("records memory usage for an observation drained before its chat reopens", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
const usage = usageLedgerFixture();
const botId = BotId.make("bot-recovered-memory");
return provideController(
Effect.gen(function* () {
// No startSession or turn: the durable queue drained after a restart.
const options = mastra.harnessOptions[0]!;
const callId = yield* Effect.promise(() =>
options.startMemoryCall!({ threadId: "thread-recovered", category: "observer" }),
);
assert.isDefined(callId);
yield* Effect.promise(() =>
Promise.resolve(
options.finishMemoryCall!({
callId,
category: "observer",
usage: { inputTokens: 120, outputTokens: 30 },
}),
),
);
expect(usage.reserve).not.toHaveBeenCalled();
expect(usage.recordMeasurement).toHaveBeenCalledWith(
expect.objectContaining({
reservationId: callId,
botId,
threadId: ThreadId.make("thread-recovered"),
category: "observer",
inputTokens: 120,
outputTokens: 30,
}),
);
}),
bridge.service,
mastra.factory,
undefined,
undefined,
usage.service,
).pipe(
Effect.provideService(
ProjectionSnapshotQuery.ProjectionSnapshotQuery,
ProjectionSnapshotQuery.ProjectionSnapshotQuery.of(
projectionQueryFixture({
getThreadRuntimeContext: () =>
Effect.succeed(Option.some(providerRuntimeContext({ botId }))),
getBotById: () => Effect.succeed(Option.none()),
getGroupById: () => Effect.succeed(Option.none()),
listThreadDelegations: () => Effect.succeed([]),
}),
),
),
);
});
});
describe("AgentControllerLive", () => {
it.effect("reserves and settles billed observational-memory usage", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
const usageLedger = usageLedgerFixture();
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
yield* resolveCodex(controller);
yield* controller.startSession(codexThreadId, {
threadId: codexThreadId,
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
modelSelection: codexSelection,
runtimeMode: "full-access",
});
const botId = BotId.make("bot-memory");
yield* controller.sendTurn({
threadId: codexThreadId,
input: "Remember this.",
botUsage: { botId },
});
const options = mastra.harnessOptions[0]!;
const callId = yield* Effect.promise(() =>
options.startMemoryCall!({ threadId: codexThreadId, category: "observer" }),
);
assert.isDefined(callId);
expect(usageLedger.reserve).toHaveBeenCalledWith(
expect.objectContaining({
reservationId: callId,
botId,
threadId: codexThreadId,
category: "observer",
maximumTokens: 32_000,
provider: "codex",
model: "gpt-5.6-sol",
}),
);
yield* Effect.promise(() =>
options.finishMemoryCall!({
callId: callId!,
category: "observer",
usage: { inputTokens: 12, outputTokens: 5, totalTokens: 17 },
}),
);
expect(usageLedger.settle).toHaveBeenCalledWith({
reservationId: callId,
state: "reported",
inputTokens: 12,
outputTokens: 5,
reasoningTokens: null,
settledAt: expect.any(String),
});
usageLedger.reserve.mockImplementationOnce(() =>
Effect.fail(new PersistenceSqlError({ operation: "BotUsageLedger.reserve" })),
);
yield* Effect.promise(() =>
expect(
options.startMemoryCall!({ threadId: codexThreadId, category: "reflector" }),
).rejects.toBeInstanceOf(PersistenceSqlError),
);
mastra.finishSend();
}),
bridge.service,
mastra.factory,
undefined,
undefined,
usageLedger.service,
);
});
});
describe("AgentControllerLive", () => {
it.effect.each([0, 1, 2])(
"settles a legacy foreground review only after one successful memory call (count: %s)",
(successfulMemoryCalls) => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
const credentials = makeMemoryOnlyCredentialOptions();
const memoryDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-review-cadence-"));
const botMemoryStore = new BotMemoryStore(memoryDir);
const botId = BotId.make("bot-legacy-review");
const groupId = GroupId.make("group-legacy-review");
const memoryAccess = {
tenantId: AkeruMemoryTenantId.make("local"),
userId: AkeruMemoryUserId.make("owner"),
threadId: claudeThreadId,
projectId: ProjectId.make("project-legacy-review"),
workspaceRoot: "/workspace/legacy-review",
botId,
groupId,
respondingBotId: botId,
groupMemberBotIds: [botId],
} as const;
const completedEvent: ProviderRuntimeEvent = {
provider: ProviderDriverKind.make("opencode"),
providerInstanceId: openCodeInstanceId,
threadId: claudeThreadId,
turnId: TurnId.make("legacy-turn"),
type: "turn.completed",
eventId: EventId.make("legacy-review-complete"),
createdAt: "2026-09-14T12:00:00.000Z",
payload: { state: "completed", stopReason: null },
};
bridge.sendTurn.mockImplementation((input) =>
completeLegacyTurnWithMemoryReview(
input,
TurnId.make("legacy-turn"),
successfulMemoryCalls,
),
);
const service = { ...bridge.service, streamEvents: Stream.succeed(completedEvent) };
return provideController(
Effect.gen(function* () {
for (let prompt = 1; prompt <= 10; prompt += 1) {
const reservation = yield* Effect.promise(() =>
botMemoryStore.reserveReviewCadence(botId, {
threadId: `group-history-${prompt}`,
groupId: String(groupId),
text: `Group prompt ${prompt}`,
}),
);
yield* Effect.promise(() => botMemoryStore.settleReviewCadence(reservation, true));
}
const controller = yield* AgentController;
yield* controller.resolveEngine({
threadId: claudeThreadId,
engine: { provider: "opencode", model: "anthropic/claude-sonnet-4-5" },
fallback: codexSelection,
mode: "default",
botConversation: true,
});
yield* controller.startSession(claudeThreadId, {
threadId: claudeThreadId,
provider: ProviderDriverKind.make("opencode"),
providerInstanceId: openCodeInstanceId,
cwd: process.cwd(),
runtimeMode: "approval-required",
botId,
botName: "OpenCode Review Bot",
memoryAccess,
});
McpMemoryToolSession.setMcpMemoryToolSession(
claudeThreadId,
createBotMemoryToolHandler(botMemoryStore, memoryAccess, new Set(["user", "group"]))
.memory,
);
yield* controller.sendTurn({ threadId: claudeThreadId, input: "Threshold prompt" });
const context = bridge.sendTurn.mock.calls[0]?.[0].persistentMemoryContext;
expect(context).toContain("<automatic-memory-review>");
expect(context).toContain("only your GROUP.md for this active group");
expect(context).toContain("Never read or change another bot's group memory");
assert.equal(
(yield* Effect.promise(() => botMemoryStore.readReviewCadence(botId, String(groupId))))
.acceptedPromptCount,
10,
);
yield* controller.streamEvents.pipe(Stream.take(1), Stream.runDrain);
assert.deepEqual(
yield* Effect.promise(() => botMemoryStore.readReviewCadence(botId, String(groupId))),
{
acceptedPromptCount: 11,
reviewedThroughPromptCount: successfulMemoryCalls === 1 ? 10 : 0,
dueOnNextAcceptedPrompt: successfulMemoryCalls !== 1,
},
);
}),
service,
mastra.factory,
undefined,
undefined,
undefined,
{ botMemoryStore, ...credentials },
).pipe(
Effect.ensuring(
Effect.sync(() => NodeFS.rmSync(memoryDir, { recursive: true, force: true })),
),
);
},
);
});