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 type * as Schema from "effect/Schema";
import * as Predicate from "effect/Predicate";
import * as NodeAssert from "node:assert/strict";
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import {
ApprovalRequestId,
ProviderDriverKind,
ProviderInstanceId,
type ProviderEvent,
} from "@akeru/contracts";
import { createModelSelection } from "@akeru/shared/model";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";
import { ServerConfig } from "../../config.ts";
import { ServerSettingsService } from "../../serverSettings.ts";
import { makeCodexAdapter } from "./CodexAdapter.ts";
import {
decodeCodexSettings,
CodexAdapter,
asThreadId,
asTurnId,
asEventId,
makeCodexAdapterHarness,
} from "./test-support/codexAdapterHarness.ts";
const {
makeRuntimeFactory,
providerSessionDirectoryTestLayer,
validationRuntimeFactory,
validationLayer,
sessionRuntimeFactory,
sessionErrorLayer,
lifecycleLayer,
startLifecycleRuntime,
scopedFailureRuntimeFactory,
scopedFailureLayer,
} = makeCodexAdapterHarness();
validationLayer("CodexAdapterLive validation", (it) => {
it.effect("maps codex model options before starting a session", () =>
Effect.gen(function* () {
validationRuntimeFactory.factory.mockClear();
const adapter = yield* CodexAdapter;
yield* adapter.startSession({
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
modelSelection: createModelSelection(ProviderInstanceId.make("codex"), "gpt-5.3-codex", [
{ id: "serviceTier", value: "priority" },
]),
runtimeMode: "full-access",
});
NodeAssert.deepStrictEqual(validationRuntimeFactory.factory.mock.calls[0]?.[0], {
binaryPath: "codex",
cwd: process.cwd(),
launchArgs: "",
model: "gpt-5.3-codex",
providerInstanceId: ProviderInstanceId.make("codex"),
serviceTier: "priority",
threadId: asThreadId("thread-1"),
runtimeMode: "full-access",
});
}),
);
});
sessionErrorLayer("CodexAdapterLive session errors", (it) => {
it.effect("uploads feedback for the active Codex thread", () =>
Effect.gen(function* () {
const adapter = yield* CodexAdapter;
const threadId = asThreadId("thread-feedback");
yield* adapter.startSession({
provider: ProviderDriverKind.make("codex"),
threadId,
runtimeMode: "full-access",
});
const runtime = sessionRuntimeFactory.lastRuntime;
NodeAssert.ok(runtime);
const result = yield* adapter.uploadFeedback({
threadId,
reason: "The agent stopped early.",
});
NodeAssert.deepStrictEqual(result, { feedbackId: "provider-thread-1" });
NodeAssert.deepStrictEqual(runtime.uploadFeedbackImpl.mock.calls, [
["The agent stopped early."],
]);
}),
);
});
sessionErrorLayer("CodexAdapterLive session errors", (it) => {
it.effect("rejects feedback for an unknown Codex thread", () =>
Effect.gen(function* () {
const adapter = yield* CodexAdapter;
const result = yield* adapter
.uploadFeedback({ threadId: asThreadId("thread-feedback-missing") })
.pipe(Effect.result);
NodeAssert.equal(result._tag, "Failure");
NodeAssert.equal(result.failure._tag, "ProviderAdapterSessionNotFoundError");
}),
);
});
sessionErrorLayer("CodexAdapterLive session errors", (it) => {
it.effect("maps codex model options before sending a turn", () =>
Effect.gen(function* () {
const adapter = yield* CodexAdapter;
yield* adapter.startSession({
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("sess-missing"),
runtimeMode: "full-access",
});
const runtime = sessionRuntimeFactory.lastRuntime;
NodeAssert.ok(runtime);
runtime.sendTurnImpl.mockClear();
yield* Effect.ignore(
adapter.sendTurn({
threadId: asThreadId("sess-missing"),
input: "hello",
modelSelection: createModelSelection(ProviderInstanceId.make("codex"), "gpt-5.3-codex", [
{ id: "reasoningEffort", value: "high" },
{ id: "serviceTier", value: "priority" },
]),
attachments: [],
}),
);
NodeAssert.deepStrictEqual(runtime.sendTurnImpl.mock.calls[0]?.[0], {
input: "hello",
model: "gpt-5.3-codex",
effort: "high",
serviceTier: "priority",
});
}),
);
});
sessionErrorLayer("CodexAdapterLive session errors", (it) => {
it.effect("passes configured launch args into the session runtime", () => {
const runtimeFactory = makeRuntimeFactory();
const layer = Layer.effect(
CodexAdapter,
Effect.gen(function* () {
const codexConfig = decodeCodexSettings({ launchArgs: "--strict-config --enable foo" });
return yield* makeCodexAdapter(codexConfig, {
makeRuntime: runtimeFactory.factory,
});
}),
).pipe(
Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
Layer.provideMerge(ServerSettingsService.layerTest()),
Layer.provideMerge(providerSessionDirectoryTestLayer),
Layer.provideMerge(NodeServices.layer),
);
return Effect.gen(function* () {
const adapter = yield* CodexAdapter;
yield* adapter.startSession({
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("sess-launch-args"),
runtimeMode: "full-access",
});
const runtime = runtimeFactory.lastRuntime;
NodeAssert.ok(runtime);
NodeAssert.equal(runtime.options.launchArgs, "--strict-config --enable foo");
}).pipe(Effect.provide(layer));
});
});
sessionErrorLayer("CodexAdapterLive session errors", (it) => {
it.effect("uses T3CODE_CODEX_LAUNCH_ARGS for the session runtime", () => {
const runtimeFactory = makeRuntimeFactory();
const layer = Layer.effect(
CodexAdapter,
Effect.gen(function* () {
const codexConfig = decodeCodexSettings({ launchArgs: "--enable settings-feature" });
return yield* makeCodexAdapter(codexConfig, {
environment: { T3CODE_CODEX_LAUNCH_ARGS: " --strict-config --enable env-feature " },
makeRuntime: runtimeFactory.factory,
});
}),
).pipe(
Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
Layer.provideMerge(ServerSettingsService.layerTest()),
Layer.provideMerge(providerSessionDirectoryTestLayer),
Layer.provideMerge(NodeServices.layer),
);
return Effect.gen(function* () {
const adapter = yield* CodexAdapter;
yield* adapter.startSession({
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("sess-launch-args-env"),
runtimeMode: "full-access",
});
const runtime = runtimeFactory.lastRuntime;
NodeAssert.ok(runtime);
NodeAssert.equal(runtime.options.launchArgs, "--strict-config --enable env-feature");
}).pipe(Effect.provide(layer));
});
});
sessionErrorLayer("CodexAdapterLive session errors", (it) => {
it.effect("maps codex model options for the adapter's bound custom instance id", () => {
const customInstanceId = ProviderInstanceId.make("codex_personal");
const customRuntimeFactory = makeRuntimeFactory();
const customLayer = Layer.effect(
CodexAdapter,
Effect.gen(function* () {
const codexConfig = decodeCodexSettings({});
return yield* makeCodexAdapter(codexConfig, {
instanceId: customInstanceId,
makeRuntime: customRuntimeFactory.factory,
});
}),
).pipe(
Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
Layer.provideMerge(ServerSettingsService.layerTest()),
Layer.provideMerge(providerSessionDirectoryTestLayer),
Layer.provideMerge(NodeServices.layer),
);
return Effect.gen(function* () {
const adapter = yield* CodexAdapter;
yield* adapter.startSession({
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("sess-custom-instance"),
runtimeMode: "full-access",
});
const runtime = customRuntimeFactory.lastRuntime;
NodeAssert.ok(runtime);
runtime.sendTurnImpl.mockClear();
yield* Effect.ignore(
adapter.sendTurn({
threadId: asThreadId("sess-custom-instance"),
input: "hello",
modelSelection: createModelSelection(
ProviderInstanceId.make("codex_personal"),
"gpt-5.3-codex",
[
{ id: "reasoningEffort", value: "high" },
{ id: "serviceTier", value: "flex" },
],
),
attachments: [],
}),
);
NodeAssert.deepStrictEqual(runtime.sendTurnImpl.mock.calls[0]?.[0], {
input: "hello",
model: "gpt-5.3-codex",
effort: "high",
serviceTier: "flex",
});
}).pipe(Effect.provide(customLayer));
});
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("does not reactivate an idle child after a parent interaction", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const eventsFiber = yield* Stream.runCollect(Stream.take(adapter.streamEvents, 3)).pipe(
Effect.forkChild,
);
const childEvent = (id: string, method: string, payload: Schema.JsonObject) => ({
id: asEventId(id),
kind: "notification" as const,
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
method,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-1"),
payload,
});
yield* runtime.emit(
childEvent("evt-child-running", "collabAgent/turnStarted", {
agentThreadId: "child-1",
agentPath: "/root/audit",
}),
);
yield* runtime.emit(
childEvent("evt-child-idle", "collabAgent/turnCompleted", {
agentThreadId: "child-1",
agentPath: "/root/audit",
turn: { status: "completed" },
}),
);
yield* runtime.emit(
childEvent("evt-child-interacted", "collabAgent/activity", {
agentThreadId: "child-1",
agentPath: "/root/audit",
activityKind: "interacted",
}),
);
yield* runtime.emit(
childEvent("evt-other-child-running", "collabAgent/turnStarted", {
agentThreadId: "child-2",
agentPath: "/root/other",
}),
);
const events = Array.from(yield* Fiber.join(eventsFiber));
NodeAssert.deepStrictEqual(
events.map((event) =>
event.type === "task.updated"
? { taskId: event.payload.taskId, status: event.payload.status }
: { type: event.type },
),
[
{ taskId: "child-1", status: "running" },
{ taskId: "child-1", status: "idle" },
{ taskId: "child-2", status: "running" },
],
);
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("preserves request type when mapping serverRequest/resolved", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
const event: ProviderEvent = {
id: asEventId("evt-request-resolved"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "serverRequest/resolved",
requestKind: "command",
requestId: ApprovalRequestId.make("req-1"),
payload: {
threadId: "thread-1",
requestId: "req-1",
},
};
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, "request.resolved");
if (firstEvent.value.type !== "request.resolved") {
return;
}
NodeAssert.equal(firstEvent.value.payload.requestType, "command_execution_approval");
}),
);
});
lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
it.effect("preserves file-read request type when mapping serverRequest/resolved", () =>
Effect.gen(function* () {
const { adapter, runtime } = yield* startLifecycleRuntime();
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
const event: ProviderEvent = {
id: asEventId("evt-file-read-request-resolved"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "serverRequest/resolved",
requestKind: "file-read",
requestId: ApprovalRequestId.make("req-file-read-1"),
payload: {
threadId: "thread-1",
requestId: "req-file-read-1",
},
};
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, "request.resolved");
if (firstEvent.value.type !== "request.resolved") {
return;
}
NodeAssert.equal(firstEvent.value.payload.requestType, "file_read_approval");
}),
);
});
scopedFailureLayer("CodexAdapterLive scoped startup failure", (it) => {
it.effect("closes the externally owned session scope when startSession fails", () =>
Effect.gen(function* () {
scopedFailureRuntimeFactory.releasedThreadIds.length = 0;
const adapter = yield* CodexAdapter;
const result = yield* adapter
.startSession({
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-fail"),
runtimeMode: "full-access",
})
.pipe(Effect.result);
NodeAssert.equal(result._tag, "Failure");
NodeAssert.equal(result.failure._tag, "ProviderAdapterProcessError");
NodeAssert.deepStrictEqual(scopedFailureRuntimeFactory.releasedThreadIds, [
asThreadId("thread-fail"),
]);
NodeAssert.equal(yield* adapter.hasSession(asThreadId("thread-fail")), false);
}),
);
});
it.effect("flushes managed native logs when the adapter layer shuts down", () =>
Effect.gen(function* () {
const tempDir = NodeFS.mkdtempSync(
NodePath.join(NodeOS.tmpdir(), "t3-codex-adapter-native-log-"),
);
const basePath = NodePath.join(tempDir, "provider-native.ndjson");
const runtimeFactory = makeRuntimeFactory();
const scope = yield* Scope.make("sequential");
let scopeClosed = false;
try {
const layer = Layer.effect(
CodexAdapter,
Effect.gen(function* () {
const codexConfig = decodeCodexSettings({});
return yield* makeCodexAdapter(codexConfig, {
makeRuntime: runtimeFactory.factory,
nativeEventLogPath: basePath,
});
}),
).pipe(
Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
Layer.provideMerge(ServerSettingsService.layerTest()),
Layer.provideMerge(providerSessionDirectoryTestLayer),
Layer.provideMerge(NodeServices.layer),
);
const context = yield* Layer.buildWithScope(layer, scope);
const adapter = yield* Effect.service(CodexAdapter).pipe(Effect.provide(context));
yield* adapter.startSession({
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-logger"),
runtimeMode: "full-access",
});
const runtime = runtimeFactory.lastRuntime;
NodeAssert.ok(runtime);
const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
yield* runtime.emit({
id: asEventId("evt-native-log"),
kind: "notification",
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-logger"),
createdAt: "2026-01-01T00:00:00.000Z",
method: "process/stderr",
message: "native flush test",
} satisfies ProviderEvent);
yield* Fiber.join(firstEventFiber);
yield* Scope.close(scope, Exit.void);
scopeClosed = true;
const threadLogPath = NodePath.join(tempDir, "provider-native.thread-logger.log");
NodeAssert.equal(NodeFS.existsSync(threadLogPath), true);
const contents = NodeFS.readFileSync(threadLogPath, "utf8");
NodeAssert.match(contents, /NTIVE: .*"message":"native flush test"/);
} finally {
if (!scopeClosed) {
yield* Scope.close(scope, Exit.void);
}
NodeFS.rmSync(tempDir, { recursive: true, force: true });
}
}),
);