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 NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import { ProviderDriverKind, ProviderInstanceId, ThreadId } from "@akeru/contracts";
import { createModelSelection } from "@akeru/shared/model";
import { it, assert } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as SqlClient from "effect/unstable/sql/SqlClient";
import { ProviderValidationError } from "../Errors.ts";
import * as ProviderAdapterRegistry from "../Services/ProviderAdapterRegistry.ts";
import * as ProviderService from "../Services/ProviderService.ts";
import * as ProviderSessionDirectory from "../Services/ProviderSessionDirectory.ts";
import { providerServiceLayerWith } from "./ProviderService.ts";
import * as ProviderEventLoggers from "./ProviderEventLoggers.ts";
import { ProviderSessionDirectoryLive } from "./ProviderSessionDirectory.ts";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as ProviderSessionRuntime from "../../persistence/ProviderSessionRuntime.ts";
import {
sqlitePersistenceLayer,
SqlitePersistenceMemory,
} from "../../persistence/Layers/Sqlite.ts";
import { adapterRegistryMock } from "../testUtils/providerAdapterRegistryMock.ts";
import {
defaultServerSettingsLayer,
serverConfigTestLayer,
asThreadId,
codexInstanceId,
claudeAgentInstanceId,
CODEX_DRIVER,
CLAUDE_AGENT_DRIVER,
makeFakeCodexAdapter,
makeProviderServiceHarness,
} from "./test-support/providerServiceHarness.ts";
const { routing } = makeProviderServiceHarness();
it.effect(
"ProviderServiceLive uploads feedback through the adapter that recovered the session",
() =>
Effect.gen(function* () {
const original = makeFakeCodexAdapter();
const replacement = makeFakeCodexAdapter();
const baseRegistry = adapterRegistryMock({ [CODEX_DRIVER]: original.adapter });
let swapAfterFirstLookup = false;
let feedbackLookupCount = 0;
const registry: ProviderAdapterRegistry.ProviderAdapterRegistry["Service"] = {
...baseRegistry,
getByInstance: (instanceId) => {
if (instanceId !== codexInstanceId) {
return baseRegistry.getByInstance(instanceId);
}
const useReplacement = swapAfterFirstLookup && feedbackLookupCount++ > 0;
return Effect.succeed(useReplacement ? replacement.adapter : original.adapter);
},
};
const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
Layer.provide(SqlitePersistenceMemory),
);
const directoryLayer = ProviderSessionDirectoryLive.pipe(
Layer.provide(runtimeRepositoryLayer),
);
const providerLayer = providerServiceLayerWith().pipe(
Layer.provide(Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, registry)),
Layer.provide(directoryLayer),
Layer.provide(defaultServerSettingsLayer),
Layer.provide(serverConfigTestLayer),
Layer.provide(
Layer.succeed(
ProviderEventLoggers.ProviderEventLoggers,
ProviderEventLoggers.NoOpProviderEventLoggers,
),
),
);
yield* Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const threadId = asThreadId("thread-feedback-adapter-replacement");
yield* provider.startSession(threadId, {
provider: CODEX_DRIVER,
providerInstanceId: codexInstanceId,
threadId,
runtimeMode: "full-access",
});
yield* original.stopSession(threadId);
original.uploadFeedback.mockClear();
replacement.uploadFeedback.mockClear();
swapAfterFirstLookup = true;
const result = yield* provider.uploadFeedback({ threadId });
assert.deepStrictEqual(result, { feedbackId: `feedback-${threadId}` });
assert.strictEqual(original.uploadFeedback.mock.calls.length, 0);
assert.deepStrictEqual(replacement.uploadFeedback.mock.calls, [[{ threadId }]]);
}).pipe(Effect.provide(providerLayer));
}).pipe(Effect.provide(NodeServices.layer)),
);
it.effect("ProviderServiceLive keeps persisted resumable sessions on startup", () =>
Effect.gen(function* () {
const tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-provider-service-"));
const dbPath = NodePath.join(tempDir, "orchestration.sqlite");
const codex = makeFakeCodexAdapter();
const registry = adapterRegistryMock({
[ProviderDriverKind.make("codex")]: codex.adapter,
});
const persistenceLayer = sqlitePersistenceLayer(dbPath);
const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
Layer.provide(persistenceLayer),
);
const directoryLayer = ProviderSessionDirectoryLive.pipe(Layer.provide(runtimeRepositoryLayer));
yield* Effect.gen(function* () {
const directory = yield* ProviderSessionDirectory.ProviderSessionDirectory;
yield* directory.upsert({
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId: ThreadId.make("thread-stale"),
});
}).pipe(Effect.provide(directoryLayer));
const providerLayer = providerServiceLayerWith().pipe(
Layer.provide(Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, registry)),
Layer.provide(directoryLayer),
Layer.provide(defaultServerSettingsLayer),
Layer.provide(serverConfigTestLayer),
Layer.provide(
Layer.succeed(
ProviderEventLoggers.ProviderEventLoggers,
ProviderEventLoggers.NoOpProviderEventLoggers,
),
),
);
yield* ProviderService.ProviderService.pipe(Effect.provide(providerLayer));
const persistedProvider = yield* Effect.gen(function* () {
const directory = yield* ProviderSessionDirectory.ProviderSessionDirectory;
return yield* directory.getProvider(asThreadId("thread-stale"));
}).pipe(Effect.provide(directoryLayer));
assert.equal(persistedProvider, "codex");
const runtime = yield* Effect.gen(function* () {
const repository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository;
return yield* repository.getByThreadId({
threadId: asThreadId("thread-stale"),
});
}).pipe(Effect.provide(runtimeRepositoryLayer));
assert.equal(Option.isSome(runtime), true);
const legacyTableRows = yield* Effect.gen(function* () {
const sql = yield* SqlClient.SqlClient;
return yield* sql<{ readonly name: string }>`
SELECT name
FROM sqlite_master
WHERE type = 'table' AND name = 'provider_sessions'
`;
}).pipe(Effect.provide(persistenceLayer));
assert.equal(legacyTableRows.length, 0);
NodeFS.rmSync(tempDir, { recursive: true, force: true });
}).pipe(Effect.provide(NodeServices.layer)),
);
it.effect(
"ProviderServiceLive restores rollback routing after restart using persisted thread mapping",
() =>
Effect.gen(function* () {
const tempDir = NodeFS.mkdtempSync(
NodePath.join(NodeOS.tmpdir(), "t3-provider-service-restart-"),
);
const dbPath = NodePath.join(tempDir, "orchestration.sqlite");
const persistenceLayer = sqlitePersistenceLayer(dbPath);
const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
Layer.provide(persistenceLayer),
);
const firstCodex = makeFakeCodexAdapter();
const firstRegistry = adapterRegistryMock({
[ProviderDriverKind.make("codex")]: firstCodex.adapter,
});
const firstDirectoryLayer = ProviderSessionDirectoryLive.pipe(
Layer.provide(runtimeRepositoryLayer),
);
const firstProviderLayer = providerServiceLayerWith().pipe(
Layer.provide(
Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, firstRegistry),
),
Layer.provide(firstDirectoryLayer),
Layer.provide(defaultServerSettingsLayer),
Layer.provide(serverConfigTestLayer),
Layer.provide(
Layer.succeed(
ProviderEventLoggers.ProviderEventLoggers,
ProviderEventLoggers.NoOpProviderEventLoggers,
),
),
);
const updatedResumeCursor = {
threadId: asThreadId("thread-1"),
resume: "resume-session-1",
resumeSessionAt: "assistant-message-1",
turnCount: 1,
};
const startedSession = yield* Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const threadId = asThreadId("thread-1");
const session = yield* provider.startSession(threadId, {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
cwd: "/tmp/project",
runtimeMode: "full-access",
threadId,
});
firstCodex.updateSession(threadId, (existing) => ({
...existing,
status: "ready",
resumeCursor: updatedResumeCursor,
updatedAt: "2026-01-01T00:00:01.000Z",
}));
return session;
}).pipe(Effect.provide(firstProviderLayer));
const persistedAfterStopAll = yield* Effect.gen(function* () {
const repository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository;
return yield* repository.getByThreadId({
threadId: startedSession.threadId,
});
}).pipe(Effect.provide(runtimeRepositoryLayer));
assert.equal(Option.isSome(persistedAfterStopAll), true);
if (Option.isSome(persistedAfterStopAll)) {
assert.equal(persistedAfterStopAll.value.status, "stopped");
assert.deepEqual(persistedAfterStopAll.value.resumeCursor, updatedResumeCursor);
}
const secondCodex = makeFakeCodexAdapter();
const secondRegistry = adapterRegistryMock({
[ProviderDriverKind.make("codex")]: secondCodex.adapter,
});
const secondDirectoryLayer = ProviderSessionDirectoryLive.pipe(
Layer.provide(runtimeRepositoryLayer),
);
const secondProviderLayer = providerServiceLayerWith().pipe(
Layer.provide(
Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, secondRegistry),
),
Layer.provide(secondDirectoryLayer),
Layer.provide(defaultServerSettingsLayer),
Layer.provide(serverConfigTestLayer),
Layer.provide(
Layer.succeed(
ProviderEventLoggers.ProviderEventLoggers,
ProviderEventLoggers.NoOpProviderEventLoggers,
),
),
);
secondCodex.startSession.mockClear();
secondCodex.rollbackThread.mockClear();
yield* Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
yield* provider.rollbackConversation({
threadId: startedSession.threadId,
numTurns: 1,
});
}).pipe(Effect.provide(secondProviderLayer));
assert.equal(secondCodex.startSession.mock.calls.length, 1);
const resumedStartInput = secondCodex.startSession.mock.calls[0]?.[0];
assert.equal(Predicate.isObject(resumedStartInput) && resumedStartInput !== null, true);
if (resumedStartInput && Predicate.isObject(resumedStartInput)) {
const startPayload = resumedStartInput as {
provider?: string;
cwd?: string;
resumeCursor?: unknown;
threadId?: string;
};
assert.equal(startPayload.provider, "codex");
assert.equal(startPayload.cwd, "/tmp/project");
assert.deepEqual(startPayload.resumeCursor, updatedResumeCursor);
assert.equal(startPayload.threadId, startedSession.threadId);
}
assert.equal(secondCodex.rollbackThread.mock.calls.length, 1);
const rollbackCall = secondCodex.rollbackThread.mock.calls[0];
assert.isTrue(Predicate.isString(rollbackCall?.[0]));
assert.equal(rollbackCall?.[1], 1);
NodeFS.rmSync(tempDir, { recursive: true, force: true });
}).pipe(Effect.provide(NodeServices.layer)),
);
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("recovers a stopped Codex session before uploading feedback", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const threadId = asThreadId("thread-feedback-recover");
yield* provider.startSession(threadId, {
provider: CODEX_DRIVER,
providerInstanceId: codexInstanceId,
threadId,
cwd: "/tmp/feedback-project",
runtimeMode: "full-access",
});
yield* routing.codex.stopSession(threadId);
routing.codex.startSession.mockClear();
routing.codex.uploadFeedback.mockClear();
const result = yield* provider.uploadFeedback({ threadId });
assert.deepStrictEqual(result, { feedbackId: `feedback-${threadId}` });
assert.strictEqual(routing.codex.startSession.mock.calls.length, 1);
assert.deepStrictEqual(routing.codex.uploadFeedback.mock.calls, [[{ threadId }]]);
}),
);
});
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("does not restart an unsupported provider before rejecting feedback", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const threadId = asThreadId("thread-feedback-unsupported-stopped");
yield* provider.startSession(threadId, {
provider: CLAUDE_AGENT_DRIVER,
providerInstanceId: claudeAgentInstanceId,
threadId,
runtimeMode: "full-access",
});
yield* routing.claude.stopSession(threadId);
routing.claude.startSession.mockClear();
const error = yield* provider.uploadFeedback({ threadId }).pipe(Effect.flip);
assert.instanceOf(error, ProviderValidationError);
assert.include(error.issue, "does not support feedback uploads");
assert.strictEqual(routing.claude.startSession.mock.calls.length, 0);
}),
);
});
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("recovers stale persisted sessions for rollback by resuming thread identity", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const initial = yield* provider.startSession(asThreadId("thread-1"), {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId: asThreadId("thread-1"),
cwd: "/tmp/project",
runtimeMode: "full-access",
});
yield* routing.codex.stopSession(initial.threadId);
routing.codex.startSession.mockClear();
routing.codex.rollbackThread.mockClear();
yield* provider.rollbackConversation({
threadId: initial.threadId,
numTurns: 1,
});
assert.equal(routing.codex.startSession.mock.calls.length, 1);
const resumedStartInput = routing.codex.startSession.mock.calls[0]?.[0];
assert.equal(Predicate.isObject(resumedStartInput) && resumedStartInput !== null, true);
if (resumedStartInput && Predicate.isObject(resumedStartInput)) {
const startPayload = resumedStartInput as {
provider?: string;
cwd?: string;
resumeCursor?: unknown;
threadId?: string;
};
assert.equal(startPayload.provider, "codex");
assert.equal(startPayload.cwd, "/tmp/project");
assert.deepEqual(startPayload.resumeCursor, initial.resumeCursor);
assert.equal(startPayload.threadId, initial.threadId);
}
assert.equal(routing.codex.rollbackThread.mock.calls.length, 1);
const rollbackCall = routing.codex.rollbackThread.mock.calls[0];
assert.equal(rollbackCall?.[1], 1);
}),
);
});
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("preserves the persisted binding when stopping a session", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const runtimeRepository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository;
const initial = yield* provider.startSession(asThreadId("thread-reap-preserve"), {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId: asThreadId("thread-reap-preserve"),
cwd: "/tmp/project-reap-preserve",
runtimeMode: "full-access",
});
yield* provider.stopSession({ threadId: initial.threadId });
const persistedAfterStop = yield* runtimeRepository.getByThreadId({
threadId: initial.threadId,
});
assert.equal(Option.isSome(persistedAfterStop), true);
if (Option.isSome(persistedAfterStop)) {
assert.equal(persistedAfterStop.value.status, "stopped");
assert.deepEqual(persistedAfterStop.value.resumeCursor, initial.resumeCursor);
}
routing.codex.startSession.mockClear();
routing.codex.sendTurn.mockClear();
yield* provider.sendTurn({
threadId: initial.threadId,
input: "resume after reap",
attachments: [],
});
assert.equal(routing.codex.startSession.mock.calls.length, 1);
const resumedStartInput = routing.codex.startSession.mock.calls[0]?.[0];
assert.equal(Predicate.isObject(resumedStartInput) && resumedStartInput !== null, true);
if (resumedStartInput && Predicate.isObject(resumedStartInput)) {
const startPayload = resumedStartInput as {
provider?: string;
cwd?: string;
resumeCursor?: unknown;
threadId?: string;
};
assert.equal(startPayload.provider, "codex");
assert.equal(startPayload.cwd, "/tmp/project-reap-preserve");
assert.deepEqual(startPayload.resumeCursor, initial.resumeCursor);
assert.equal(startPayload.threadId, initial.threadId);
}
assert.equal(routing.codex.sendTurn.mock.calls.length, 1);
}),
);
});
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("dies when an active session conflicts with its persisted binding", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const directory = yield* ProviderSessionDirectory.ProviderSessionDirectory;
const threadId = asThreadId("thread-binding-mismatch");
yield* provider.startSession(threadId, {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId,
cwd: "/tmp/project-binding-mismatch",
runtimeMode: "full-access",
});
yield* directory.upsert({
threadId,
provider: ProviderDriverKind.make("claudeAgent"),
providerInstanceId: claudeAgentInstanceId,
runtimeMode: "full-access",
});
const exit = yield* Effect.exit(provider.listSessions());
assert.equal(Exit.hasDies(exit), true);
yield* directory.upsert({
threadId,
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
runtimeMode: "full-access",
});
}),
);
});
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("recovers stale sessions for sendTurn using persisted cwd", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const initial = yield* provider.startSession(asThreadId("thread-1"), {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId: asThreadId("thread-1"),
cwd: "/tmp/project-send-turn",
runtimeMode: "full-access",
});
yield* routing.codex.stopAll();
routing.codex.startSession.mockClear();
routing.codex.sendTurn.mockClear();
yield* provider.sendTurn({
threadId: initial.threadId,
input: "resume",
attachments: [],
});
assert.equal(routing.codex.startSession.mock.calls.length, 1);
const resumedStartInput = routing.codex.startSession.mock.calls[0]?.[0];
assert.equal(Predicate.isObject(resumedStartInput) && resumedStartInput !== null, true);
if (resumedStartInput && Predicate.isObject(resumedStartInput)) {
const startPayload = resumedStartInput as {
provider?: string;
cwd?: string;
resumeCursor?: unknown;
threadId?: string;
};
assert.equal(startPayload.provider, "codex");
assert.equal(startPayload.cwd, "/tmp/project-send-turn");
assert.deepEqual(startPayload.resumeCursor, initial.resumeCursor);
assert.equal(startPayload.threadId, initial.threadId);
}
assert.equal(routing.codex.sendTurn.mock.calls.length, 1);
}),
);
});
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("recovers stale claudeAgent sessions for sendTurn using persisted cwd", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const initial = yield* provider.startSession(asThreadId("thread-claude-send-turn"), {
provider: ProviderDriverKind.make("claudeAgent"),
providerInstanceId: claudeAgentInstanceId,
threadId: asThreadId("thread-claude-send-turn"),
cwd: "/tmp/project-claude-send-turn",
modelSelection: createModelSelection(
ProviderInstanceId.make("claudeAgent"),
"claude-opus-4-6",
[{ id: "effort", value: "max" }],
),
runtimeMode: "full-access",
});
yield* routing.claude.stopAll();
routing.claude.startSession.mockClear();
routing.claude.sendTurn.mockClear();
yield* provider.sendTurn({
threadId: initial.threadId,
input: "resume with claude",
attachments: [],
});
assert.equal(routing.claude.startSession.mock.calls.length, 1);
const resumedStartInput = routing.claude.startSession.mock.calls[0]?.[0];
assert.equal(Predicate.isObject(resumedStartInput) && resumedStartInput !== null, true);
if (resumedStartInput && Predicate.isObject(resumedStartInput)) {
const startPayload = resumedStartInput as {
provider?: string;
cwd?: string;
modelSelection?: unknown;
resumeCursor?: unknown;
threadId?: string;
};
assert.equal(startPayload.provider, "claudeAgent");
assert.equal(startPayload.cwd, "/tmp/project-claude-send-turn");
assert.deepEqual(
startPayload.modelSelection,
createModelSelection(ProviderInstanceId.make("claudeAgent"), "claude-opus-4-6", [
{ id: "effort", value: "max" },
]),
);
assert.deepEqual(startPayload.resumeCursor, initial.resumeCursor);
assert.equal(startPayload.threadId, initial.threadId);
}
assert.equal(routing.claude.sendTurn.mock.calls.length, 1);
}),
);
});
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("persists runtime status transitions in provider_session_runtime", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const runtimeRepository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository;
const threadId = asThreadId("thread-runtime-status");
const session = yield* provider.startSession(threadId, {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId,
runtimeMode: "full-access",
});
yield* provider.sendTurn({
threadId: session.threadId,
input: "hello",
attachments: [],
});
const runningRuntime = yield* runtimeRepository.getByThreadId({
threadId: session.threadId,
});
assert.equal(Option.isSome(runningRuntime), true);
if (Option.isSome(runningRuntime)) {
assert.equal(runningRuntime.value.status, "running");
assert.deepEqual(runningRuntime.value.resumeCursor, session.resumeCursor);
const payload = runningRuntime.value.runtimePayload;
assert.equal(payload !== null && Predicate.isObject(payload), true);
if (payload !== null && Predicate.isObject(payload) && !Array.isArray(payload)) {
const runtimePayload = payload as {
cwd: string;
model: string | null;
activeTurnId: string | null;
lastError: string | null;
lastRuntimeEvent: string | null;
};
assert.equal(runtimePayload.cwd, session.cwd);
assert.equal(runtimePayload.model, null);
assert.equal(runtimePayload.activeTurnId, `turn-${String(session.threadId)}`);
assert.equal(runtimePayload.lastError, null);
assert.equal(runtimePayload.lastRuntimeEvent, "provider.sendTurn");
}
}
}),
);
});