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 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 { ProviderAdapterValidationError } from "../Errors.ts";
import {
CodexAdapter,
asThreadId,
asEventId,
makeCodexAdapterHarness,
} from "./test-support/codexAdapterHarness.ts";
const {
validationRuntimeFactory,
validationLayer,
sessionErrorLayer,
lifecycleLayer,
startLifecycleRuntime,
scopedLifecycleRuntimeFactory,
scopedLifecycleLayer,
} = makeCodexAdapterHarness();
validationLayer("CodexAdapterLive validation", (it) => {
it.effect("returns validation error for non-codex provider on startSession", () =>
Effect.gen(function* () {
const adapter = yield* CodexAdapter;
const result = yield* adapter
.startSession({
provider: ProviderDriverKind.make("claudeAgent"),
threadId: asThreadId("thread-1"),
runtimeMode: "full-access",
})
.pipe(Effect.result);
NodeAssert.equal(result._tag, "Failure");
NodeAssert.deepStrictEqual(
result.failure,
new ProviderAdapterValidationError({
provider: ProviderDriverKind.make("codex"),
operation: "startSession",
issue: "Expected provider 'codex' but received 'claudeAgent'.",
}),
);
NodeAssert.equal(validationRuntimeFactory.factory.mock.calls.length, 0);
}),
);
});
sessionErrorLayer("CodexAdapterLive session errors", (it) => {
it.effect("maps missing adapter sessions to ProviderAdapterSessionNotFoundError", () =>
Effect.gen(function* () {
const adapter = yield* CodexAdapter;
const result = yield* adapter
.sendTurn({
threadId: asThreadId("sess-missing"),
input: "hello",
attachments: [],
})
.pipe(Effect.result);
NodeAssert.equal(result._tag, "Failure");
NodeAssert.equal(result.failure._tag, "ProviderAdapterSessionNotFoundError");
NodeAssert.equal(result.failure.provider, "codex");
NodeAssert.equal(result.failure.threadId, "sess-missing");
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("maps windowsSandbox/setupCompleted to session state and warning on failure", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const eventsFiber = yield* Stream.runCollect(Stream.take(adapter.streamEvents, 2)).pipe(
Effect.forkChild,
);
const event: ProviderEvent = {
id: asEventId("evt-windows-sandbox-failed"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "windowsSandbox/setupCompleted",
message: "Sandbox setup failed",
payload: {
mode: "unelevated",
success: false,
error: "unsupported environment",
},
};
yield* runtime.emit(event);
const events = Array.from(yield* Fiber.join(eventsFiber));
NodeAssert.equal(events.length, 2);
const firstEvent = events[0];
const secondEvent = events[1];
NodeAssert.equal(firstEvent?.type, "session.state.changed");
if (firstEvent?.type === "session.state.changed") {
NodeAssert.equal(firstEvent.payload.state, "error");
NodeAssert.equal(firstEvent.payload.reason, "Sandbox setup failed");
}
NodeAssert.equal(secondEvent?.type, "runtime.warning");
if (secondEvent?.type === "runtime.warning") {
NodeAssert.equal(secondEvent.payload.message, "Sandbox setup failed");
}
}),
);
});
scopedLifecycleLayer("CodexAdapterLive scoped lifecycle", (it) => {
it.effect("closes the externally owned session scope on stopSession", () =>
Effect.gen(function* () {
scopedLifecycleRuntimeFactory.releasedThreadIds.length = 0;
const adapter = yield* CodexAdapter;
yield* adapter.startSession({
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-stop"),
runtimeMode: "full-access",
});
const runtime = scopedLifecycleRuntimeFactory.lastRuntime;
NodeAssert.ok(runtime);
yield* adapter.stopSession(asThreadId("thread-stop"));
NodeAssert.equal(runtime.closeImpl.mock.calls.length, 1);
NodeAssert.deepStrictEqual(scopedLifecycleRuntimeFactory.releasedThreadIds, [
asThreadId("thread-stop"),
]);
NodeAssert.equal(yield* adapter.hasSession(asThreadId("thread-stop")), false);
}),
);
});