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 * as Predicate from "effect/Predicate";
import { assert, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Ref from "effect/Ref";
import * as Stream from "effect/Stream";
import type * as EffectAcpSchema from "effect-acp/schema";
import {
ApprovalRequestId,
ProviderDriverKind,
ProviderInstanceId,
ThreadId,
TurnId,
type ProviderRuntimeEvent,
} from "@akeru/contracts";
import {
grokPromptSettlementBelongsToContext,
makeGrokAdapter,
selectGrokPermissionOptionId,
} from "./GrokAdapter.ts";
import {
decodeGrokSettings,
makeMockGrokWrapper,
grokAdapterTestLayer,
makeTestAdapter,
} from "./test-support/grokAdapterHarness.ts";
it("falls back to allow_once when Grok omits allow_always", () => {
const request = {
sessionId: "session-1",
toolCall: { toolCallId: "tool-1", title: "run", kind: "execute" },
options: [
{ optionId: "allow-once", name: "Allow once", kind: "allow_once" },
{ optionId: "reject-once", name: "Reject", kind: "reject_once" },
],
} satisfies EffectAcpSchema.RequestPermissionRequest;
assert.equal(selectGrokPermissionOptionId(request, "acceptForSession"), "allow-once");
assert.equal(selectGrokPermissionOptionId(request, "accept"), "allow-once");
});
it("requires a settlement to match the live Grok turn", () => {
const staleTurnId = TurnId.make("stale-turn");
const replacementTurnId = TurnId.make("replacement-turn");
assert.isFalse(
grokPromptSettlementBelongsToContext({
liveAcpSessionId: "session-1",
expectedAcpSessionId: "session-1",
liveActiveTurnId: replacementTurnId,
liveSessionActiveTurnId: replacementTurnId,
turnId: staleTurnId,
}),
);
assert.isFalse(
grokPromptSettlementBelongsToContext({
liveAcpSessionId: "replacement-session",
expectedAcpSessionId: "stale-session",
liveActiveTurnId: staleTurnId,
liveSessionActiveTurnId: staleTurnId,
turnId: staleTurnId,
}),
);
assert.isTrue(
grokPromptSettlementBelongsToContext({
liveAcpSessionId: "session-1",
expectedAcpSessionId: "session-1",
liveActiveTurnId: staleTurnId,
liveSessionActiveTurnId: staleTurnId,
turnId: staleTurnId,
}),
);
});
it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
it.effect("starts a session and maps mock ACP prompt flow to runtime events", () =>
Effect.gen(function* () {
const threadId = ThreadId.make("grok-mock-thread");
const wrapperPath = yield* Effect.promise(() => makeMockGrokWrapper());
const adapter = yield* makeTestAdapter(wrapperPath);
const runtimeEvents: ProviderRuntimeEvent[] = [];
const turnCompleted = yield* Deferred.make<void>();
const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>
Effect.sync(() => {
runtimeEvents.push(event);
}).pipe(
Effect.andThen(
event.type === "turn.completed"
? Deferred.succeed(turnCompleted, undefined)
: Effect.void,
),
),
).pipe(Effect.forkChild);
const session = yield* adapter.startSession({
threadId,
provider: ProviderDriverKind.make("grok"),
cwd: process.cwd(),
runtimeMode: "full-access",
modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-mock-alt" },
});
assert.equal(session.provider, "grok");
assert.equal(session.model, "grok-mock-alt");
assert.deepStrictEqual(session.resumeCursor, {
schemaVersion: 1,
sessionId: "mock-session-1",
});
yield* adapter.sendTurn({
threadId,
input: "hello grok",
attachments: [],
});
yield* Deferred.await(turnCompleted);
yield* Fiber.interrupt(runtimeEventsFiber);
const types = runtimeEvents.map((e) => e.type);
assert.includeMembers(types, [
"session.started",
"session.state.changed",
"thread.started",
"turn.started",
"item.started",
"content.delta",
"turn.completed",
] as const);
const delta = runtimeEvents.find((e) => e.type === "content.delta");
assert.isDefined(delta);
if (delta?.type === "content.delta") {
assert.equal(delta.payload.delta, "hello from mock");
}
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
it.effect("reports a Grok session running only while the prompt is in flight", () =>
Effect.gen(function* () {
const threadId = ThreadId.make("grok-session-ready-after-prompt");
const wrapperPath = yield* Effect.promise(() =>
makeMockGrokWrapper({
T3_ACP_EMIT_TOOL_CALLS: "1",
}),
);
const adapter = yield* makeTestAdapter(wrapperPath);
const requestOpened =
yield* Deferred.make<Extract<ProviderRuntimeEvent, { type: "request.opened" }>>();
const eventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>
event.type === "request.opened"
? Deferred.succeed(requestOpened, event).pipe(Effect.ignore)
: Effect.void,
).pipe(Effect.forkChild);
yield* adapter.startSession({
threadId,
provider: ProviderDriverKind.make("grok"),
cwd: process.cwd(),
runtimeMode: "approval-required",
modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },
});
const sendTurnFiber = yield* adapter
.sendTurn({ threadId, input: "check lifecycle", attachments: [] })
.pipe(Effect.forkChild);
const requestOpenedEvent = yield* Deferred.await(requestOpened);
const runningSessions = yield* adapter.listSessions();
const runningSession = runningSessions.find((session) => session.threadId === threadId);
assert.equal(runningSession?.status, "running");
assert.isDefined(runningSession?.activeTurnId);
yield* adapter.respondToRequest(
threadId,
ApprovalRequestId.make(String(requestOpenedEvent.requestId)),
"accept",
);
yield* Fiber.join(sendTurnFiber);
const readySessions = yield* adapter.listSessions();
const readySession = readySessions.find((session) => session.threadId === threadId);
assert.equal(readySession?.status, "ready");
assert.isUndefined(readySession?.activeTurnId);
yield* Fiber.interrupt(eventsFiber);
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
it.effect("restores ready without completing an unstarted turn when preparation fails", () =>
Effect.gen(function* () {
const threadId = ThreadId.make("grok-preparation-failure-while-connecting");
const wrapperPath = yield* Effect.promise(() => makeMockGrokWrapper());
const adapter = yield* makeTestAdapter(wrapperPath);
const runtimeEvents: ProviderRuntimeEvent[] = [];
const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>
Effect.sync(() => {
runtimeEvents.push(event);
}),
).pipe(Effect.forkChild);
yield* adapter.startSession({
threadId,
provider: ProviderDriverKind.make("grok"),
cwd: process.cwd(),
runtimeMode: "full-access",
modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },
});
const error = yield* Effect.flip(
adapter.sendTurn({
threadId,
input: "prepare invalid attachment",
attachments: [
{
type: "image",
id: "missing-image",
name: "missing.png",
mimeType: "image/png",
sizeBytes: 1,
},
],
}),
);
for (let yieldAttempt = 0; yieldAttempt < 4; yieldAttempt += 1) {
yield* Effect.yieldNow;
}
const turnCompletedEvent = runtimeEvents.find(
(event): event is Extract<ProviderRuntimeEvent, { type: "turn.completed" }> =>
event.type === "turn.completed",
);
const readySessions = yield* adapter.listSessions();
const readySession = readySessions.find((session) => session.threadId === threadId);
assert.equal(error._tag, "ProviderAdapterRequestError");
assert.isUndefined(turnCompletedEvent);
assert.equal(readySession?.status, "ready");
assert.isUndefined(readySession?.activeTurnId);
yield* Fiber.interrupt(runtimeEventsFiber);
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
it.effect("completes a Grok turn from xAI prompt completion when the prompt RPC hangs", () =>
Effect.gen(function* () {
const threadId = ThreadId.make("grok-xai-prompt-complete-fallback");
const wrapperPath = yield* Effect.promise(() =>
makeMockGrokWrapper({
T3_ACP_EMIT_XAI_PROMPT_COMPLETE_THEN_HANG: "1",
T3_ACP_EMIT_FOREIGN_SESSION_UPDATES: "1",
}),
);
const adapter = yield* makeTestAdapter(wrapperPath);
const runtimeEvents: ProviderRuntimeEvent[] = [];
const turnCompleted = yield* Deferred.make<void>();
const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>
Effect.sync(() => {
runtimeEvents.push(event);
}).pipe(
Effect.andThen(
event.type === "turn.completed"
? Deferred.succeed(turnCompleted, undefined)
: Effect.void,
),
),
).pipe(Effect.forkChild);
yield* adapter.startSession({
threadId,
provider: ProviderDriverKind.make("grok"),
cwd: process.cwd(),
runtimeMode: "full-access",
modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },
});
const sendTurnResult = yield* adapter.sendTurn({
threadId,
input: "exercise fallback",
attachments: [],
});
yield* Deferred.await(turnCompleted);
for (let yieldAttempt = 0; yieldAttempt < 8; yieldAttempt += 1) {
yield* Effect.yieldNow;
}
const readySessions = yield* adapter.listSessions();
const readySession = readySessions.find((session) => session.threadId === threadId);
const turnCompletedEvent = runtimeEvents.find(
(event): event is Extract<ProviderRuntimeEvent, { type: "turn.completed" }> =>
event.type === "turn.completed",
);
const eventTypes = runtimeEvents.map((event) => event.type);
const content = runtimeEvents
.flatMap((event) =>
event.type === "content.delta" && String(event.threadId) === String(threadId)
? [event.payload.delta]
: [],
)
.join("");
const terminalIndex = runtimeEvents.findIndex(
(event) => event.type === "turn.completed" && String(event.threadId) === String(threadId),
);
const turnOutputTypes = new Set([
"content.delta",
"item.started",
"item.updated",
"item.completed",
"turn.plan.updated",
]);
const outputAfterTerminal = runtimeEvents
.slice(terminalIndex + 1)
.filter(
(event) => String(event.threadId) === String(threadId) && turnOutputTypes.has(event.type),
);
const toolTitles = runtimeEvents.flatMap((event) =>
event.type === "item.updated" && event.payload.title ? [event.payload.title] : [],
);
assert.equal(sendTurnResult.threadId, threadId);
assert.include(eventTypes, "turn.completed");
assert.equal(content, "hello from mock");
assert.isAtLeast(terminalIndex, 0);
assert.deepEqual(outputAfterTerminal, []);
assert.notInclude(toolTitles, "Child-only tool");
assert.equal(turnCompletedEvent?.payload.stopReason, "end_turn");
assert.equal(readySession?.status, "ready");
assert.isUndefined(readySession?.activeTurnId);
yield* Fiber.interrupt(runtimeEventsFiber);
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
it.effect("settles the in-flight prompt before emitting completion", () =>
Effect.gen(function* () {
const threadId = ThreadId.make("grok-completion-before-next-turn");
const wrapperPath = yield* Effect.promise(() => makeMockGrokWrapper());
const adapter = yield* makeTestAdapter(wrapperPath);
const completedCountRef = yield* Ref.make(0);
const secondTurnCompleted = yield* Deferred.make<void>();
const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) => {
if (event.type !== "turn.completed" || String(event.threadId) !== String(threadId)) {
return Effect.void;
}
return Ref.modify(completedCountRef, (count) => {
const nextCount = count + 1;
return [nextCount, nextCount] as const;
}).pipe(
Effect.flatMap((count) => {
if (count === 1) {
return adapter
.sendTurn({
threadId,
input: "second turn after completion",
attachments: [],
})
.pipe(Effect.forkChild, Effect.asVoid);
}
if (count === 2) {
return Deferred.succeed(secondTurnCompleted, undefined).pipe(Effect.asVoid);
}
return Effect.void;
}),
);
}).pipe(Effect.forkChild);
yield* adapter.startSession({
threadId,
provider: ProviderDriverKind.make("grok"),
cwd: process.cwd(),
runtimeMode: "full-access",
modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },
});
yield* adapter.sendTurn({
threadId,
input: "first turn",
attachments: [],
});
yield* Deferred.await(secondTurnCompleted);
const completedCount = yield* Ref.get(completedCountRef);
const readySessions = yield* adapter.listSessions();
const readySession = readySessions.find((session) => session.threadId === threadId);
assert.equal(completedCount, 2);
assert.equal(readySession?.status, "ready");
assert.isUndefined(readySession?.activeTurnId);
yield* Fiber.interrupt(runtimeEventsFiber);
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
it.effect("restores a Grok session to ready when the prompt RPC fails", () =>
Effect.gen(function* () {
const threadId = ThreadId.make("grok-prompt-failure-ready");
const wrapperPath = yield* Effect.promise(() =>
makeMockGrokWrapper({
T3_ACP_FAIL_PROMPT: "1",
}),
);
const adapter = yield* makeTestAdapter(wrapperPath);
const runtimeEvents: ProviderRuntimeEvent[] = [];
const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>
Effect.sync(() => {
runtimeEvents.push(event);
}),
).pipe(Effect.forkChild);
yield* adapter.startSession({
threadId,
provider: ProviderDriverKind.make("grok"),
cwd: process.cwd(),
runtimeMode: "full-access",
modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },
});
const error = yield* Effect.flip(
adapter.sendTurn({
threadId,
input: "fail prompt",
attachments: [],
}),
);
const readySessions = yield* adapter.listSessions();
const readySession = readySessions.find((session) => session.threadId === threadId);
const failedTurnCompleted = runtimeEvents.find(
(event) => event.type === "turn.completed" && event.threadId === threadId,
);
assert.equal(error._tag, "ProviderAdapterRequestError");
assert.equal(readySession?.status, "ready");
assert.isUndefined(readySession?.activeTurnId);
assert.equal(failedTurnCompleted?.type, "turn.completed");
if (failedTurnCompleted?.type === "turn.completed") {
assert.equal(failedTurnCompleted.payload.state, "failed");
assert.isString(failedTurnCompleted.payload.errorMessage);
}
yield* Fiber.interrupt(runtimeEventsFiber);
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
it.effect("ignores replayed session/load updates when resuming a Grok session", () =>
Effect.gen(function* () {
const threadId = ThreadId.make("grok-load-replay-filter");
const wrapperPath = yield* Effect.promise(() =>
makeMockGrokWrapper({
T3_ACP_EMIT_LOAD_REPLAY: "1",
}),
);
const adapter = yield* makeTestAdapter(wrapperPath);
const runtimeEvents: ProviderRuntimeEvent[] = [];
const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>
Effect.sync(() => {
runtimeEvents.push(event);
}),
).pipe(Effect.forkChild);
const session = yield* adapter.startSession({
threadId,
provider: ProviderDriverKind.make("grok"),
cwd: process.cwd(),
runtimeMode: "full-access",
modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },
resumeCursor: { schemaVersion: 1, sessionId: "mock-session-1" },
});
yield* adapter.sendTurn({
threadId,
input: "after resume",
attachments: [],
});
assert.deepStrictEqual(session.resumeCursor, {
schemaVersion: 1,
sessionId: "mock-session-1",
});
assert.isFalse(
runtimeEvents.some(
(event) => event.type === "item.completed" && event.payload.title === "Replay tool",
),
);
assert.isFalse(
runtimeEvents.some(
(event) =>
event.type === "content.delta" && event.payload.delta === "replayed assistant text",
),
);
yield* Fiber.interrupt(runtimeEventsFiber);
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
it.effect("rejects startSession when provider mismatches", () =>
Effect.gen(function* () {
const wrapperPath = yield* Effect.promise(() => makeMockGrokWrapper());
const adapter = yield* makeTestAdapter(wrapperPath);
const threadId = ThreadId.make("grok-provider-mismatch");
const error = yield* Effect.flip(
adapter.startSession({
threadId,
provider: ProviderDriverKind.make("cursor"),
cwd: process.cwd(),
runtimeMode: "full-access",
modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },
}),
);
assert.equal(error._tag, "ProviderAdapterValidationError");
}),
);
});
it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
it.effect("rejects sendTurn with empty input and no attachments", () =>
Effect.gen(function* () {
const threadId = ThreadId.make("grok-empty-turn");
const wrapperPath = yield* Effect.promise(() => makeMockGrokWrapper());
const adapter = yield* makeTestAdapter(wrapperPath);
yield* adapter.startSession({
threadId,
provider: ProviderDriverKind.make("grok"),
cwd: process.cwd(),
runtimeMode: "full-access",
modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },
});
const error = yield* Effect.flip(
adapter.sendTurn({
threadId,
input: " ",
attachments: [],
}),
);
assert.equal(error._tag, "ProviderAdapterValidationError");
yield* adapter.stopSession(threadId);
}),
);
});
it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {
it.effect("enables ACP protocol logging from Grok settings", () =>
Effect.gen(function* () {
const wrapperPath = yield* Effect.promise(() => makeMockGrokWrapper());
const protocolLogged = yield* Deferred.make<void>();
const adapter = yield* makeGrokAdapter(
decodeGrokSettings({ binaryPath: wrapperPath, verboseProtocolLogging: true }),
{
nativeEventLogger: {
filePath: "memory://grok-native-events",
write: <Input>(record: Input) =>
Predicate.isObject(record) &&
record !== null &&
"event" in record &&
Predicate.isObject(record.event) &&
record.event !== null &&
"kind" in record.event &&
record.event.kind === "protocol"
? Deferred.succeed(protocolLogged, undefined).pipe(Effect.asVoid)
: Effect.void,
close: () => Effect.void,
},
},
).pipe(Effect.orDie);
const threadId = ThreadId.make("grok-verbose-protocol-log");
yield* adapter.startSession({
threadId,
provider: ProviderDriverKind.make("grok"),
cwd: process.cwd(),
runtimeMode: "full-access",
});
yield* Deferred.await(protocolLogged);
yield* adapter.stopSession(threadId);
}),
);
});