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 { 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 * as TestClock from "effect/testing/TestClock";
import {
CodexAdapter,
asThreadId,
asTurnId,
asEventId,
asItemId,
makeCodexAdapterHarness,
} from "./test-support/codexAdapterHarness.ts";
const { lifecycleRuntimeFactory, lifecycleLayer, startLifecycleRuntime } =
makeCodexAdapterHarness();
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("maps completed agent message items to canonical item.completed events", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
const event: ProviderEvent = {
id: asEventId("evt-msg-complete"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "item/completed",
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-1"),
itemId: asItemId("msg_1"),
payload: {
completedAtMs: 1_778_000_000_000,
threadId: "thread-1",
turnId: "turn-1",
item: {
type: "agentMessage",
id: "msg_1",
text: "done",
},
},
};
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, "item.completed");
if (firstEvent.value.type !== "item.completed") {
return;
}
NodeAssert.equal(firstEvent.value.itemId, "msg_1");
NodeAssert.equal(firstEvent.value.turnId, "turn-1");
NodeAssert.equal(firstEvent.value.payload.itemType, "assistant_message");
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("labels MCP lifecycle entries with server and tool names", () =>
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-complete"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "item/completed",
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-1"),
itemId: asItemId("mcp_1"),
payload: {
completedAtMs: 1_778_000_000_000,
threadId: "thread-1",
turnId: "turn-1",
item: {
type: "mcpToolCall",
id: "mcp_1",
server: "akeru",
tool: "preview_status",
arguments: {},
durationMs: 12,
error: null,
result: { content: [{ type: "text", text: "attached" }] },
status: "completed",
},
},
});
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some") || firstEvent.value.type !== "item.completed") {
return;
}
NodeAssert.equal(firstEvent.value.payload.itemType, "mcp_tool_call");
NodeAssert.equal(firstEvent.value.payload.title, "akeru · preview_status");
NodeAssert.deepStrictEqual(firstEvent.value.payload.data, {
completedAtMs: 1_778_000_000_000,
threadId: "thread-1",
turnId: "turn-1",
item: {
type: "mcpToolCall",
id: "mcp_1",
server: "akeru",
tool: "preview_status",
arguments: {},
durationMs: 12,
error: null,
result: { content: [{ type: "text", text: "attached" }] },
status: "completed",
},
});
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("preserves failed and declined outcomes on completed tool items", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const items = [
{
type: "commandExecution",
id: "failed-command",
command: "vp test run",
commandActions: [],
cwd: "/tmp",
exitCode: 1,
status: "failed",
},
{
type: "mcpToolCall",
id: "failed-mcp",
server: "simulator",
tool: "build",
arguments: {},
error: { message: "Build failed" },
status: "failed",
},
{
type: "fileChange",
id: "declined-change",
changes: [],
status: "declined",
},
] as const;
for (const item of items) {
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId(`evt-${item.id}`),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "item/completed",
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-1"),
itemId: asItemId(item.id),
payload: {
completedAtMs: 1_778_000_000_000,
threadId: "thread-1",
turnId: "turn-1",
item,
},
});
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some") || firstEvent.value.type !== "item.completed") {
return;
}
NodeAssert.equal(firstEvent.value.payload.status, item.status);
}
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("maps completed plan items to canonical proposed-plan completion events", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
const event: ProviderEvent = {
id: asEventId("evt-plan-complete"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "item/completed",
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-1"),
itemId: asItemId("plan_1"),
payload: {
completedAtMs: 1_778_000_000_000,
threadId: "thread-1",
turnId: "turn-1",
item: {
type: "plan",
id: "plan_1",
text: "## Final plan\n\n- one\n- two",
},
},
};
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, "turn.proposed.completed");
if (firstEvent.value.type !== "turn.proposed.completed") {
return;
}
NodeAssert.equal(firstEvent.value.turnId, "turn-1");
NodeAssert.equal(firstEvent.value.payload.planMarkdown, "## Final plan\n\n- one\n- two");
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("maps plan deltas to canonical proposed-plan delta events", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId("evt-plan-delta"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "item/plan/delta",
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-1"),
itemId: asItemId("plan_1"),
payload: {
threadId: "thread-1",
turnId: "turn-1",
itemId: "plan_1",
delta: "## Final plan",
},
} satisfies ProviderEvent);
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some")) {
return;
}
NodeAssert.equal(firstEvent.value.type, "turn.proposed.delta");
if (firstEvent.value.type !== "turn.proposed.delta") {
return;
}
NodeAssert.equal(firstEvent.value.turnId, "turn-1");
NodeAssert.equal(firstEvent.value.payload.delta, "## Final plan");
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("maps session/closed lifecycle events to canonical session.exited runtime events", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
const event: ProviderEvent = {
id: asEventId("evt-session-closed"),
kind: "session",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "session/closed",
message: "Session stopped",
};
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, "session.exited");
if (firstEvent.value.type !== "session.exited") {
return;
}
NodeAssert.equal(firstEvent.value.threadId, "thread-1");
NodeAssert.equal(firstEvent.value.payload.reason, "Session stopped");
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("maps retryable Codex error notifications to runtime.warning", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId("evt-retryable-error"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "error",
turnId: asTurnId("turn-1"),
payload: {
threadId: "thread-1",
turnId: "turn-1",
error: {
message: "Reconnecting... 2/5",
},
willRetry: true,
},
} satisfies ProviderEvent);
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some")) {
return;
}
NodeAssert.equal(firstEvent.value.type, "runtime.warning");
if (firstEvent.value.type !== "runtime.warning") {
return;
}
NodeAssert.equal(firstEvent.value.turnId, "turn-1");
NodeAssert.equal(firstEvent.value.payload.message, "Reconnecting... 2/5");
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("maps process stderr notifications to runtime.warning", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId("evt-process-stderr"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "process/stderr",
turnId: asTurnId("turn-1"),
message: "The filename or extension is too long. (os error 206)",
} satisfies ProviderEvent);
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some")) {
return;
}
NodeAssert.equal(firstEvent.value.type, "runtime.warning");
if (firstEvent.value.type !== "runtime.warning") {
return;
}
NodeAssert.equal(firstEvent.value.turnId, "turn-1");
NodeAssert.equal(
firstEvent.value.payload.message,
"The filename or extension is too long. (os error 206)",
);
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("maps realtime started notifications with upstream realtime session ids", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId("evt-realtime-started"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "thread/realtime/started",
payload: {
threadId: "thread-1",
realtimeSessionId: "realtime-session-1",
version: "v2",
},
} satisfies ProviderEvent);
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some")) {
return;
}
NodeAssert.equal(firstEvent.value.type, "thread.realtime.started");
if (firstEvent.value.type !== "thread.realtime.started") {
return;
}
NodeAssert.equal(firstEvent.value.threadId, "thread-1");
NodeAssert.equal(firstEvent.value.payload.realtimeSessionId, "realtime-session-1");
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("maps fatal websocket stderr notifications to runtime.error", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId("evt-process-stderr-websocket"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "process/stderr",
turnId: asTurnId("turn-1"),
message:
"2026-03-31T18:14:06.833399Z ERROR codex_api::endpoint::responses_websocket: failed to connect to websocket: HTTP error: 503 Service Unavailable, url: wss://chatgpt.com/backend-api/codex/responses",
} satisfies ProviderEvent);
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some")) {
return;
}
NodeAssert.equal(firstEvent.value.type, "runtime.error");
if (firstEvent.value.type !== "runtime.error") {
return;
}
NodeAssert.equal(firstEvent.value.turnId, "turn-1");
NodeAssert.equal(firstEvent.value.payload.class, "provider_error");
NodeAssert.equal(
firstEvent.value.payload.message,
"2026-03-31T18:14:06.833399Z ERROR codex_api::endpoint::responses_websocket: failed to connect to websocket: HTTP error: 503 Service Unavailable, url: wss://chatgpt.com/backend-api/codex/responses",
);
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("unwraps Codex token usage payloads for context window events", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId("evt-codex-thread-token-usage-updated"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "thread/tokenUsage/updated",
payload: {
threadId: "thread-1",
turnId: "turn-1",
tokenUsage: {
total: {
inputTokens: 11_833,
cachedInputTokens: 3456,
outputTokens: 6,
reasoningOutputTokens: 0,
totalTokens: 11_839,
},
last: {
inputTokens: 120,
cachedInputTokens: 0,
outputTokens: 6,
reasoningOutputTokens: 0,
totalTokens: 126,
},
modelContextWindow: 258_400,
},
},
} satisfies ProviderEvent);
const firstEvent = yield* Fiber.join(firstEventFiber);
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some")) {
return;
}
NodeAssert.equal(firstEvent.value.type, "thread.token-usage.updated");
if (firstEvent.value.type !== "thread.token-usage.updated") {
return;
}
NodeAssert.deepEqual(firstEvent.value.payload.usage, {
usedTokens: 126,
totalProcessedTokens: 11_839,
maxTokens: 258_400,
inputTokens: 120,
cachedInputTokens: 0,
outputTokens: 6,
reasoningOutputTokens: 0,
lastUsedTokens: 126,
lastInputTokens: 120,
lastCachedInputTokens: 0,
lastOutputTokens: 6,
lastReasoningOutputTokens: 0,
compactsAutomatically: true,
});
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("accumulates independent model-call usage within a turn", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const eventsFiber = yield* Stream.runCollect(Stream.take(adapter.streamEvents, 3)).pipe(
Effect.forkChild,
);
for (const [index, totalTokens] of [400, 800, 1_200].entries()) {
yield* runtime.emit({
id: asEventId(`evt-codex-usage-${index}`),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "thread/tokenUsage/updated",
payload: {
threadId: "thread-1",
turnId: "turn-1",
tokenUsage: {
total: {
inputTokens: totalTokens - 100,
cachedInputTokens: 0,
outputTokens: 100,
reasoningOutputTokens: 0,
totalTokens,
},
last: {
inputTokens: 300,
cachedInputTokens: 0,
outputTokens: 100,
reasoningOutputTokens: 0,
totalTokens: 400,
},
modelContextWindow: 258_400,
},
},
} satisfies ProviderEvent);
}
const events = Array.from(yield* Fiber.join(eventsFiber));
NodeAssert.deepEqual(
events.map((event) =>
event.type === "thread.token-usage.updated" ? event.payload.usage.lastUsedTokens : null,
),
[400, 800, 1_200],
);
NodeAssert.deepEqual(
events.map((event) =>
event.type === "thread.token-usage.updated" ? event.payload.usage.lastInputTokens : null,
),
[300, 600, 900],
);
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("keeps consuming runtime events after the startSession fiber completes", () =>
Effect.gen(function* () {
const adapter = yield* CodexAdapter;
const startSessionFiber = yield* adapter
.startSession({
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-outlives-start"),
runtimeMode: "full-access",
})
.pipe(Effect.forkChild);
yield* Fiber.join(startSessionFiber);
const runtime = lifecycleRuntimeFactory.lastRuntime;
NodeAssert.ok(runtime);
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId("evt-after-start-session"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "item/completed",
threadId: asThreadId("thread-outlives-start"),
turnId: asTurnId("turn-1"),
itemId: asItemId("msg_after_start"),
payload: {
completedAtMs: 1_778_000_000_000,
threadId: "thread-outlives-start",
turnId: "turn-1",
item: {
type: "agentMessage",
id: "msg_after_start",
text: "emitted after startSession returned",
},
},
});
const firstEvent = yield* Fiber.join(firstEventFiber).pipe(Effect.timeout("10 seconds"));
NodeAssert.equal(firstEvent._tag, "Some");
if (!Predicate.isTagged(firstEvent, "Some")) {
return;
}
NodeAssert.equal(firstEvent.value.type, "item.completed");
// Live clock so the timeout above is real: under the default test clock it
// waits on virtual time that never advances, and a regression would hang
// until the suite timeout instead of failing here.
}).pipe(TestClock.withLive),
);
});