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 { codexHarnessModelIds, GROK_HARNESS_MODELS } from "../HarnessProviderStatus.ts";
import * as Predicate from "effect/Predicate";
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import type { AgentControllerEvent } from "@mastra/core/agent-controller";
import {
ApprovalRequestId,
EventId,
ProviderDriverKind,
ProviderInstanceId,
ThreadId,
TurnId,
type ProviderRuntimeEvent,
} from "@akeru/contracts";
import { it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Stream from "effect/Stream";
import { assert, describe, expect } from "vite-plus/test";
import { AgentController } from "../Services/AgentController.ts";
import { recordProviderAccessHealth } from "./AgentController.ts";
import { makeTestSubscriptionAuthService } from "../../subscription-auth/testUtils/subscriptionAuthService.ts";
import {
codexThreadId,
claudeThreadId,
grokThreadId,
kimiThreadId,
codexInstanceId,
claudeInstanceId,
grokInstanceId,
kimiInstanceId,
codexSelection,
instanceModelCatalog,
} from "./test-support/agentControllerFixtures.ts";
import {
makeBridge,
provideController,
resolveCodex,
switchCases,
kimiStartInput,
resolveKimi,
} from "./test-support/agentControllerLayers.ts";
import { mastraHarnessFixture, assistantMessage } from "./test-support/agentControllerHarness.ts";
describe("provider access health", () => {
it("records the model a failed turn ran on with the instance failure", async () => {
const directory = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-access-model-"));
try {
const service = await makeTestSubscriptionAuthService(
NodePath.join(directory, "subscription-auth.json"),
);
recordProviderAccessHealth(
service,
{
provider: ProviderDriverKind.make("codex"),
providerInstanceId: ProviderInstanceId.make("codex"),
threadId: ThreadId.make("thread-model"),
turnId: TurnId.make("turn-model"),
type: "turn.completed",
eventId: EventId.make("evt-model-failed"),
createdAt: "2026-08-30T20:00:00.000Z",
payload: { state: "failed", stopReason: null, errorMessage: "Model gpt-typo not found" },
},
"gpt-typo",
);
expect(service.providerInstanceRequestHealth("codex")?.lastFailedRequest).toEqual({
at: "2026-08-30T20:00:00.000Z",
message: "Model gpt-typo not found",
model: "gpt-typo",
});
} finally {
NodeFS.rmSync(directory, { recursive: true, force: true });
}
});
});
describe("AgentControllerLive", () => {
it.effect("runs Codex turns through Mastra Session.sendMessage and normalizes events", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
yield* resolveCodex(controller);
const session = yield* controller.startSession(codexThreadId, {
threadId: codexThreadId,
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
cwd: process.cwd(),
modelSelection: codexSelection,
runtimeMode: "full-access",
});
assert.equal(session.provider, "codex");
const events: ProviderRuntimeEvent[] = [];
const eventsFiber = yield* controller.streamEvents.pipe(
Stream.runForEach((event) =>
Effect.sync(() => {
events.push(event);
}),
),
Effect.forkChild({ startImmediately: true }),
);
yield* Effect.yieldNow;
yield* controller.sendTurn({ threadId: codexThreadId, input: "Reply once." });
mastra.emit({
type: "message_update",
message: assistantMessage("Mastra"),
} as AgentControllerEvent);
mastra.emit({
type: "message_end",
message: assistantMessage("Mastra answer"),
} as AgentControllerEvent);
mastra.emit({ type: "agent_end", reason: "complete" } as AgentControllerEvent);
mastra.finishSend();
yield* Effect.yieldNow;
yield* Effect.yieldNow;
yield* Fiber.interrupt(eventsFiber);
assert.deepEqual(
events.slice(0, 6).map((event) => event.type),
[
"turn.started",
"session.state.changed",
"item.started",
"content.delta",
"item.completed",
"turn.completed",
],
);
assert.equal(
events
.flatMap((event) => (event.type === "content.delta" ? [event.payload.delta] : []))
.join(""),
"Mastra answer",
);
expect(mastra.sendMessage).toHaveBeenCalledWith({ content: "Reply once." });
expect(bridge.startSession).not.toHaveBeenCalled();
expect(bridge.sendTurn).not.toHaveBeenCalled();
}),
bridge.service,
mastra.factory,
);
});
});
describe("AgentControllerLive", () => {
it.effect("normalizes legacy plan input when running Claude through Mastra", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
const resolved = yield* controller.resolveEngine({
threadId: claudeThreadId,
engine: { provider: "claudeAgent", model: "claude-fable-5" },
fallback: codexSelection,
mode: "plan",
botConversation: true,
});
assert.equal(resolved.mode, "default");
yield* controller.startSession(claudeThreadId, {
threadId: claudeThreadId,
provider: ProviderDriverKind.make("claudeAgent"),
providerInstanceId: claudeInstanceId,
cwd: process.cwd(),
runtimeMode: "approval-required",
});
const result = yield* controller.sendTurn({
threadId: claudeThreadId,
input: "Use Claude.",
});
expect(String(result.turnId)).toMatch(/^mastra-turn-/);
expect(bridge.startSession).not.toHaveBeenCalled();
expect(bridge.sendTurn).not.toHaveBeenCalled();
expect(mastra.createSession).toHaveBeenCalledOnce();
expect(mastra.session.model.switch).toHaveBeenCalledWith({
modelId: "anthropic/claude-fable-5[1m]",
});
expect(mastra.session.mode.switch).not.toHaveBeenCalledWith({ modeId: "plan" });
expect(mastra.sendMessage).toHaveBeenCalledOnce();
}),
bridge.service,
mastra.factory,
);
});
});
describe("AgentControllerLive", () => {
it.effect("runs Grok through the Akeru Mastra harness", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
yield* controller.resolveEngine({
threadId: grokThreadId,
engine: { provider: "grok", model: "grok-code-fast-1" },
fallback: codexSelection,
mode: "default",
botConversation: true,
});
yield* controller.startSession(grokThreadId, {
threadId: grokThreadId,
provider: ProviderDriverKind.make("grok"),
providerInstanceId: grokInstanceId,
cwd: process.cwd(),
runtimeMode: "approval-required",
});
const result = yield* controller.sendTurn({
threadId: grokThreadId,
input: "Use Grok.",
});
expect(String(result.turnId)).toMatch(/^mastra-turn-/);
expect(bridge.startSession).not.toHaveBeenCalled();
expect(bridge.sendTurn).not.toHaveBeenCalled();
expect(mastra.createSession).toHaveBeenCalledOnce();
expect(mastra.session.model.switch).toHaveBeenCalledWith({
modelId: "xai/grok-code-fast-1",
});
expect(mastra.sendMessage).toHaveBeenCalledOnce();
}),
bridge.service,
mastra.factory,
);
});
});
describe("AgentControllerLive", () => {
it.effect("runs the saved Kimi model through Mastra without provider fallback", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
yield* controller.resolveEngine({
threadId: kimiThreadId,
engine: { provider: String(kimiInstanceId), model: "k3-256k" },
fallback: codexSelection,
mode: "default",
botConversation: true,
});
const session = yield* controller.startSession(kimiThreadId, {
threadId: kimiThreadId,
provider: ProviderDriverKind.make("kimi"),
providerInstanceId: kimiInstanceId,
cwd: process.cwd(),
modelSelection: { instanceId: kimiInstanceId, model: "k3-256k" },
runtimeMode: "approval-required",
});
assert.equal(session.provider, "kimi");
assert.equal(session.model, "k3-256k");
expect(mastra.session.model.switch).toHaveBeenCalledWith({
modelId: "kimi-for-coding/k3-256k",
});
expect(bridge.startSession).not.toHaveBeenCalled();
expect(bridge.getCapabilities).not.toHaveBeenCalled();
}),
bridge.service,
mastra.factory,
);
});
});
describe("AgentControllerLive", () => {
describe("in-session model switch between turns", () => {
for (const testCase of switchCases) {
it.effect(
`switches the saved ${testCase.provider} model in-session between turns via resolveEngine`,
() => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
const model = (model: string) => ({
instanceId: testCase.instanceId,
model,
});
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
const resolve = (model: string) =>
controller.resolveEngine({
threadId: testCase.threadId,
engine: { provider: String(testCase.instanceId), model },
fallback: codexSelection,
mode: "default",
botConversation: true,
});
yield* resolve(testCase.from);
yield* controller.startSession(testCase.threadId, {
threadId: testCase.threadId,
provider: ProviderDriverKind.make(testCase.provider),
providerInstanceId: testCase.instanceId,
cwd: process.cwd(),
modelSelection: model(testCase.from),
runtimeMode: "approval-required",
});
yield* controller.sendTurn({
threadId: testCase.threadId,
input: "First turn.",
});
yield* Effect.yieldNow;
mastra.emit({ type: "agent_end", reason: "complete" } as AgentControllerEvent);
mastra.finishSend();
yield* Effect.yieldNow;
expect(mastra.session.model.switch).toHaveBeenCalledWith({
modelId: `${testCase.wirePrefix}/${testCase.from}${testCase.provider === "claudeAgent" ? "[1m]" : ""}`,
});
yield* resolve(testCase.to);
expect(mastra.session.model.switch).toHaveBeenCalledWith({
modelId: `${testCase.wirePrefix}/${testCase.to}${testCase.provider === "claudeAgent" ? "[1m]" : ""}`,
});
expect(mastra.createSession).toHaveBeenCalledOnce();
const completed = yield* controller.streamEvents.pipe(
Stream.filter((event) => event.type === "turn.completed"),
Stream.runHead,
Effect.forkChild({ startImmediately: true }),
);
yield* controller.sendTurn({
threadId: testCase.threadId,
input: "Second turn.",
modelSelection: model(testCase.to),
});
yield* Effect.yieldNow;
mastra.emit({ type: "agent_end", reason: "complete" } as AgentControllerEvent);
mastra.finishSend();
assert.equal((yield* Fiber.join(completed))._tag, "Some");
const [session] = yield* controller.listSessions();
assert.equal(session?.model, testCase.to);
expect(mastra.sendMessage).toHaveBeenNthCalledWith(2, {
content: "Second turn.",
});
expect(bridge.sendTurn).not.toHaveBeenCalled();
}),
bridge.service,
mastra.factory,
);
},
);
}
});
});
describe("AgentControllerLive", () => {
describe("in-session model switch between turns", () => {
it.effect(
"continues an existing engine using a historical Codex model outside currentModels",
() => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
instanceModelCatalog.set(String(codexInstanceId), {
models: codexHarnessModelIds(["gpt-6-sol"]),
});
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
const resolved = yield* controller.resolveEngine({
threadId: codexThreadId,
engine: { provider: "codex", model: "gpt-5.4" },
fallback: codexSelection,
mode: "default",
botConversation: true,
});
assert.equal(resolved.modelSelection.model, "gpt-5.4");
}),
bridge.service,
mastra.factory,
);
},
);
for (const model of ["grok-4.6", "grok-4.5"] as const) {
it.effect(`continues an existing ready Grok engine using ${model}`, () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
instanceModelCatalog.set(String(grokInstanceId), { models: [...GROK_HARNESS_MODELS] });
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
const resolved = yield* controller.resolveEngine({
threadId: grokThreadId,
engine: { provider: "grok", model },
fallback: { instanceId: grokInstanceId, model: "grok-build" },
mode: "default",
botConversation: true,
});
assert.equal(resolved.modelSelection.model, model);
}),
bridge.service,
mastra.factory,
);
});
}
it.effect("preserves an existing Claude engine and its 1M context selection", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
instanceModelCatalog.set(String(claudeInstanceId), { models: ["claude-opus-4-6"] });
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
const resolved = yield* controller.resolveEngine({
threadId: claudeThreadId,
engine: {
provider: "claudeAgent",
model: "claude-opus-4-6",
options: [{ id: "contextWindow", value: "1m" }],
},
fallback: { instanceId: claudeInstanceId, model: "claude-fable-5" },
mode: "default",
botConversation: true,
});
assert.equal(resolved.modelSelection.model, "claude-opus-4-6");
yield* controller.startSession(claudeThreadId, {
threadId: claudeThreadId,
provider: ProviderDriverKind.make("claudeAgent"),
providerInstanceId: claudeInstanceId,
cwd: process.cwd(),
runtimeMode: "approval-required",
});
expect(mastra.session.model.switch).toHaveBeenCalledWith({
modelId: "anthropic/claude-opus-4-6[1m]",
});
}),
bridge.service,
mastra.factory,
);
});
it.effect("fails closed when the saved model is not in the instance snapshot", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
instanceModelCatalog.set(String(codexInstanceId), { models: ["gpt-5.6-sol"] });
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
const failure = yield* Effect.flip(
controller.resolveEngine({
threadId: codexThreadId,
engine: { provider: "codex", model: "not-a-model" },
fallback: codexSelection,
mode: "default",
botConversation: true,
}),
);
assert.equal(failure._tag, "AgentControllerUnsupportedEngineError");
if (Predicate.isTagged(failure, "AgentControllerUnsupportedEngineError")) {
assert.include(failure.detail, "Model 'not-a-model' is not available for codex.");
assert.equal(failure.unavailability, "unsupported-model");
}
expect(mastra.createSession).not.toHaveBeenCalled();
}),
bridge.service,
mastra.factory,
);
});
});
});
describe("AgentControllerLive", () => {
describe("in-session model switch between turns", () => {
it.effect("allows a saved model advertised through the instance snapshot", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
instanceModelCatalog.set(String(codexInstanceId), {
models: ["gpt-5.6-sol", "custom-codex"],
});
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
const resolved = yield* controller.resolveEngine({
threadId: codexThreadId,
engine: { provider: "codex", model: "custom-codex" },
fallback: codexSelection,
mode: "default",
botConversation: true,
});
assert.equal(resolved.modelSelection.model, "custom-codex");
}),
bridge.service,
mastra.factory,
);
});
});
});
describe("AgentControllerLive", () => {
describe("in-session model switch between turns", () => {
it.effect("does not fail closed on a pending snapshot's model list", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
// A pending probe still advertises the built-in catalog. The saved model
// may be real but only show up once the probe finishes, so the check
// must not reject it.
instanceModelCatalog.set(String(codexInstanceId), {
models: ["gpt-5.6-sol"],
status: "warning",
});
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
const resolved = yield* controller.resolveEngine({
threadId: codexThreadId,
engine: { provider: "codex", model: "cli-only-model" },
fallback: codexSelection,
mode: "default",
botConversation: true,
});
assert.equal(resolved.modelSelection.model, "cli-only-model");
}),
bridge.service,
mastra.factory,
);
});
});
});
describe("AgentControllerLive", () => {
describe("Kimi Mastra normalization", () => {
it.effect("normalizes a full Kimi turn with a tool call over the Mastra session", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
yield* resolveKimi(controller);
yield* controller.startSession(kimiThreadId, kimiStartInput("k3-256k"));
const events: ProviderRuntimeEvent[] = [];
const eventsFiber = yield* controller.streamEvents.pipe(
Stream.runForEach((event) => Effect.sync(() => events.push(event))),
Effect.forkChild({ startImmediately: true }),
);
const completed = yield* controller.streamEvents.pipe(
Stream.filter(
(event) => event.type === "turn.completed" && event.payload.state === "completed",
),
Stream.runHead,
Effect.forkChild({ startImmediately: true }),
);
yield* Effect.yieldNow;
yield* controller.sendTurn({ threadId: kimiThreadId, input: "Read this file." });
yield* Effect.yieldNow;
mastra.emit({
type: "tool_start",
toolCallId: "read-1",
toolName: "read_file",
args: { path: "README.md" },
} as AgentControllerEvent);
mastra.emit({
type: "tool_end",
toolCallId: "read-1",
result: "file contents",
isError: false,
} as AgentControllerEvent);
mastra.emit({
type: "message_end",
message: {
...assistantMessage("Kimi answer"),
threadId: String(kimiThreadId),
resourceId: String(kimiThreadId),
},
} as AgentControllerEvent);
mastra.emit({ type: "agent_end", reason: "complete" } as AgentControllerEvent);
mastra.finishSend();
const completedEvent = yield* Fiber.join(completed);
assert.equal(completedEvent._tag, "Some");
yield* Fiber.interrupt(eventsFiber);
const types = events.map((event) => event.type);
for (const expected of [
"turn.started",
"session.state.changed",
"item.started",
"item.completed",
"content.delta",
"turn.completed",
]) {
assert.include(types, expected);
}
const itemStarted = events.find((event) => event.type === "item.started");
expect(itemStarted).toMatchObject({
payload: { itemType: "file_change", title: "read_file" },
});
const toolItem = events.find(
(event) => event.type === "item.completed" && String(event.itemId ?? "") === "read-1",
);
expect(toolItem).toMatchObject({ payload: { status: "completed" } });
expect(mastra.sendMessage).toHaveBeenCalledWith({ content: "Read this file." });
expect(mastra.session.model.switch).toHaveBeenCalledWith({
modelId: "kimi-for-coding/k3-256k",
});
expect(bridge.startSession).not.toHaveBeenCalled();
expect(bridge.sendTurn).not.toHaveBeenCalled();
}),
bridge.service,
mastra.factory,
);
});
});
});
describe("AgentControllerLive", () => {
describe("Kimi Mastra normalization", () => {
it.effect("normalizes a Kimi approval denial to the Mastra session", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
yield* resolveKimi(controller);
yield* controller.startSession(kimiThreadId, kimiStartInput("k3-256k"));
const resolved = yield* controller.streamEvents.pipe(
Stream.filter(
(event) => event.type === "request.resolved" && event.payload.outcome === "denied",
),
Stream.runHead,
Effect.forkChild({ startImmediately: true }),
);
const turnEvents = yield* controller.streamEvents.pipe(
Stream.filter(
(event) =>
event.type === "turn.completed" ||
(event.type === "item.completed" && String(event.itemId ?? "") === "shell-1"),
),
Stream.take(2),
Stream.runCollect,
Effect.forkChild({ startImmediately: true }),
);
yield* Effect.yieldNow;
yield* controller.sendTurn({ threadId: kimiThreadId, input: "Run a shell command." });
yield* Effect.yieldNow;
mastra.emit({
type: "tool_approval_required",
toolCallId: "shell-1",
toolName: "Shell",
args: { command: "rm -rf build" },
} as AgentControllerEvent);
yield* Effect.yieldNow;
yield* controller.respondToRequest({
threadId: kimiThreadId,
requestId: ApprovalRequestId.make("shell-1"),
decision: "decline",
});
const resolvedEvent = yield* Fiber.join(resolved);
assert.equal(resolvedEvent._tag, "Some");
expect(mastra.session.respondToToolApproval).toHaveBeenCalledWith({
toolCallId: "shell-1",
decision: "decline",
});
expect(bridge.respondToRequest).not.toHaveBeenCalled();
// The denied tool ends the call and the turn can still finish.
mastra.emit({
type: "tool_end",
toolCallId: "shell-1",
result: "denied",
denied: true,
} as AgentControllerEvent);
mastra.emit({ type: "agent_end", reason: "complete" } as AgentControllerEvent);
mastra.finishSend();
const events = yield* Fiber.join(turnEvents);
const completed = [...events].find((event) => event.type === "turn.completed");
const itemCompleted = [...events].find((event) => event.type === "item.completed");
assert.equal(completed?.type, "turn.completed");
if (completed?.type === "turn.completed") {
assert.equal(completed.payload.state, "completed");
}
expect(itemCompleted).toMatchObject({ payload: { status: "declined" } });
const [session] = yield* controller.listSessions();
assert.isUndefined(session?.activeTurnId);
}),
bridge.service,
mastra.factory,
);
});
});
});
describe("AgentControllerLive", () => {
describe("Kimi Mastra normalization", () => {
it.effect("normalizes interrupting a Kimi turn mid-flight through Mastra abort", () => {
const bridge = makeBridge();
const mastra = mastraHarnessFixture();
return provideController(
Effect.gen(function* () {
const controller = yield* AgentController;
yield* resolveKimi(controller);
yield* controller.startSession(kimiThreadId, kimiStartInput("k3-256k"));
const interrupted = yield* controller.streamEvents.pipe(
Stream.filter(
(event) => event.type === "turn.completed" && event.payload.state === "interrupted",
),
Stream.runHead,
Effect.forkChild({ startImmediately: true }),
);
const turn = yield* controller.sendTurn({
threadId: kimiThreadId,
input: "Work on this forever.",
});
yield* Effect.yieldNow;
yield* controller.interruptTurn({ threadId: kimiThreadId });
const event = yield* Fiber.join(interrupted);
assert.equal(event._tag, "Some");
if (Predicate.isTagged(event, "Some")) {
assert.equal(event.value.turnId, turn.turnId);
}
expect(mastra.session.abort).toHaveBeenCalledOnce();
expect(bridge.interruptTurn).not.toHaveBeenCalled();
const [session] = yield* controller.listSessions();
assert.isUndefined(session?.activeTurnId);
}),
bridge.service,
mastra.factory,
);
});
});
});