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 * as NodeAssert from "node:assert/strict";
import { ApprovalRequestId, ProviderDriverKind, type ProviderEvent } from "@akeru/contracts";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Stream from "effect/Stream";
import {
asThreadId,
asTurnId,
asEventId,
makeCodexAdapterHarness,
} from "./test-support/codexAdapterHarness.ts";
const { lifecycleLayer, startLifecycleRuntime } = makeCodexAdapterHarness();
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("maps MCP elicitation requests into app access approvals", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId("evt-mcp-elicitation"),
kind: "request",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-08-24T00:00:00.000Z",
method: "mcpServer/elicitation/request",
requestKind: "mcp-elicitation",
requestId: ApprovalRequestId.make("req-safari"),
turnId: asTurnId("turn-1"),
payload: {
mode: "form",
message: "Allow ChatGPT to use Safari?",
serverName: "computer-use",
threadId: "provider-thread-1",
turnId: "turn-1",
_meta: { app_name: "Safari", persist: ["session", "always"] },
requestedSchema: { type: "object", properties: {} },
},
} satisfies ProviderEvent);
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some") || firstEvent.value.type !== "request.opened") {
return;
}
NodeAssert.equal(firstEvent.value.payload.requestType, "mcp_elicitation_approval");
NodeAssert.equal(firstEvent.value.payload.appName, "Safari");
NodeAssert.equal(firstEvent.value.payload.detail, "Allow ChatGPT to use Safari?");
NodeAssert.deepStrictEqual(firstEvent.value.payload.options, [
{ decision: "cancel", label: "Cancel" },
{ decision: "decline", label: "Decline" },
{ decision: "acceptForSession", label: "Always allow this session" },
{ decision: "acceptAlways", label: "Always allow" },
{ decision: "accept", label: "Approve" },
]);
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("preserves MCP elicitation type when an app access request resolves", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId("evt-mcp-elicitation-resolved"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-08-24T00:00:00.000Z",
method: "item/requestApproval/decision",
requestKind: "mcp-elicitation",
requestId: ApprovalRequestId.make("req-safari"),
payload: { decision: "acceptAlways" },
} satisfies ProviderEvent);
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some") || firstEvent.value.type !== "request.resolved") {
return;
}
NodeAssert.equal(firstEvent.value.payload.requestType, "mcp_elicitation_approval");
NodeAssert.equal(firstEvent.value.payload.decision, "acceptAlways");
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("preserves explicit empty multi-select user-input answers", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
const event: ProviderEvent = {
id: asEventId("evt-user-input-empty"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "item/tool/requestUserInput/answered",
payload: {
answers: {
scope: {
answers: [],
},
},
},
};
yield* runtime.emit(event);
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some")) {
return;
}
NodeAssert.equal(firstEvent.value.type, "user-input.resolved");
if (firstEvent.value.type !== "user-input.resolved") {
return;
}
NodeAssert.deepEqual(firstEvent.value.payload.answers, {
scope: [],
});
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect(
"maps requestUserInput requests and answered notifications to canonical user-input events",
() =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const eventsFiber = yield* Stream.runCollect(Stream.take(adapter.streamEvents, 2)).pipe(
Effect.forkChild,
);
yield* runtime.emit({
id: asEventId("evt-user-input-requested"),
kind: "request",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "item/tool/requestUserInput",
requestId: ApprovalRequestId.make("req-user-input-1"),
payload: {
itemId: "item-user-input-1",
threadId: "thread-1",
turnId: "turn-1",
questions: [
{
id: "sandbox_mode",
header: "Sandbox",
question: "Which mode should be used?",
options: [
{
label: "workspace-write",
description: "Allow workspace writes only",
},
],
},
],
},
} satisfies ProviderEvent);
yield* runtime.emit({
id: asEventId("evt-user-input-resolved"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "item/tool/requestUserInput/answered",
requestId: ApprovalRequestId.make("req-user-input-1"),
payload: {
answers: {
sandbox_mode: {
answers: ["workspace-write"],
},
},
},
} satisfies ProviderEvent);
const events = Array.from(yield* Fiber.join(eventsFiber));
NodeAssert.equal(events[0]?.type, "user-input.requested");
if (events[0]?.type === "user-input.requested") {
NodeAssert.equal(events[0].requestId, "req-user-input-1");
NodeAssert.equal(events[0].payload.questions[0]?.id, "sandbox_mode");
NodeAssert.equal(events[0].payload.questions[0]?.multiSelect, false);
}
NodeAssert.equal(events[1]?.type, "user-input.resolved");
if (events[1]?.type === "user-input.resolved") {
NodeAssert.equal(events[1].requestId, "req-user-input-1");
NodeAssert.deepEqual(events[1].payload.answers, {
sandbox_mode: "workspace-write",
});
}
}),
);
});