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 type { ProviderSendTurnInput, ProviderSession } from "@akeru/contracts";
import {
ProviderDriverKind,
ProviderInstanceId,
ProviderSessionStartInput,
} from "@akeru/contracts";
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 Scope from "effect/Scope";
import { ProviderAdapterRequestError } from "../Errors.ts";
import * as ProviderAdapterRegistry from "../Services/ProviderAdapterRegistry.ts";
import * as ProviderService from "../Services/ProviderService.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 { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts";
import { adapterRegistryMock } from "../testUtils/providerAdapterRegistryMock.ts";
import {
defaultServerSettingsLayer,
serverConfigTestLayer,
asRequestId,
asThreadId,
codexInstanceId,
claudeAgentInstanceId,
CODEX_DRIVER,
makeFakeCodexAdapter,
activeSessionThreadId,
makeProviderServiceHarness,
} from "./test-support/providerServiceHarness.ts";
const { routing, validation, listThreadIds, getBinding, boundedListing } =
makeProviderServiceHarness();
it.effect("ProviderServiceLive catches stopAll failures during shutdown", () =>
Effect.gen(function* () {
const codex = makeFakeCodexAdapter();
codex.stopAll.mockImplementation(() =>
Effect.fail(
new ProviderAdapterRequestError({
provider: String(CODEX_DRIVER),
method: "stopAll",
detail: "simulated stopAll failure",
}),
),
);
const registry = adapterRegistryMock({
[CODEX_DRIVER]: codex.adapter,
});
const providerAdapterLayer = Layer.succeed(
ProviderAdapterRegistry.ProviderAdapterRegistry,
registry,
);
const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
Layer.provide(SqlitePersistenceMemory),
);
const directoryLayer = ProviderSessionDirectoryLive.pipe(Layer.provide(runtimeRepositoryLayer));
const providerLayer = Layer.mergeAll(
providerServiceLayerWith().pipe(
Layer.provide(providerAdapterLayer),
Layer.provide(directoryLayer),
Layer.provide(defaultServerSettingsLayer),
Layer.provide(serverConfigTestLayer),
Layer.provide(
Layer.succeed(
ProviderEventLoggers.ProviderEventLoggers,
ProviderEventLoggers.NoOpProviderEventLoggers,
),
),
),
directoryLayer,
runtimeRepositoryLayer,
NodeServices.layer,
);
const scope = yield* Scope.make();
const runtimeServices = yield* Layer.build(providerLayer).pipe(Scope.provide(scope));
yield* ProviderService.ProviderService.pipe(Effect.provide(runtimeServices));
const closeExit = yield* Scope.close(scope, Exit.void).pipe(Effect.exit);
assert.equal(Exit.isSuccess(closeExit), true);
assert.equal(codex.stopAll.mock.calls.length, 1);
}),
);
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("routes provider operations and rollback conversation", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const session = yield* provider.startSession(asThreadId("thread-1"), {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId: asThreadId("thread-1"),
cwd: "/tmp/project",
runtimeMode: "full-access",
});
assert.equal(session.provider, "codex");
const sessions = yield* provider.listSessions();
assert.equal(sessions.length, 1);
yield* provider.sendTurn({
threadId: session.threadId,
input: "hello",
attachments: [],
});
assert.equal(routing.codex.sendTurn.mock.calls.length, 1);
yield* provider.interruptTurn({ threadId: session.threadId });
assert.deepEqual(routing.codex.interruptTurn.mock.calls, [[session.threadId, undefined]]);
yield* provider.respondToRequest({
threadId: session.threadId,
requestId: asRequestId("req-1"),
decision: "accept",
});
assert.deepEqual(routing.codex.respondToRequest.mock.calls, [
[session.threadId, asRequestId("req-1"), "accept"],
]);
yield* provider.respondToUserInput({
threadId: session.threadId,
requestId: asRequestId("req-user-input-1"),
answers: {
sandbox_mode: "workspace-write",
},
});
assert.deepEqual(routing.codex.respondToUserInput.mock.calls, [
[
session.threadId,
asRequestId("req-user-input-1"),
{
sandbox_mode: "workspace-write",
},
],
]);
yield* provider.rollbackConversation({
threadId: session.threadId,
numTurns: 0,
});
yield* provider.stopSession({ threadId: session.threadId });
routing.codex.startSession.mockClear();
routing.codex.sendTurn.mockClear();
yield* provider.sendTurn({
threadId: session.threadId,
input: "after-stop",
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");
assert.deepEqual(startPayload.resumeCursor, session.resumeCursor);
assert.equal(startPayload.threadId, session.threadId);
}
assert.equal(routing.codex.sendTurn.mock.calls.length, 1);
}),
);
});
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("appends attachment file paths to the turn input text", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const session = yield* provider.startSession(asThreadId("thread-attach"), {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId: asThreadId("thread-attach"),
cwd: "/tmp/project",
runtimeMode: "full-access",
});
const attachment = {
type: "image" as const,
id: "thread-attach-12345678-1234-1234-1234-123456789abc",
name: "screenshot.png",
mimeType: "image/png",
sizeBytes: 123,
};
routing.codex.sendTurn.mockClear();
yield* provider.sendTurn({
threadId: session.threadId,
input: "use this screenshot",
attachments: [attachment],
});
const turnInput = routing.codex.sendTurn.mock.calls[0]?.[0] as ProviderSendTurnInput;
assert.isTrue(Predicate.isString(turnInput.input));
const turnText = turnInput.input ?? "";
assert.equal(turnText.startsWith("use this screenshot"), true);
assert.include(turnText, '[Attached image "screenshot.png" is saved at: ');
assert.equal(turnText.endsWith(`${attachment.id}.png]`), true);
// An attachment-only turn stays valid and the injected line becomes the
// whole input text, so the agent still learns the path.
routing.codex.sendTurn.mockClear();
yield* provider.sendTurn({
threadId: session.threadId,
attachments: [attachment],
});
const imageOnlyInput = routing.codex.sendTurn.mock.calls[0]?.[0] as ProviderSendTurnInput;
assert.equal(imageOnlyInput.input?.startsWith('[Attached image "screenshot.png"'), true);
yield* provider.stopSession({ threadId: session.threadId });
}),
);
});
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("routes explicit claudeAgent provider session starts to the claude adapter", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const session = yield* provider.startSession(asThreadId("thread-claude"), {
provider: ProviderDriverKind.make("claudeAgent"),
providerInstanceId: claudeAgentInstanceId,
threadId: asThreadId("thread-claude"),
cwd: "/tmp/project-claude",
runtimeMode: "full-access",
});
assert.equal(session.provider, "claudeAgent");
assert.equal(routing.claude.startSession.mock.calls.length, 1);
const startInput = routing.claude.startSession.mock.calls[0]?.[0];
assert.equal(Predicate.isObject(startInput) && startInput !== null, true);
if (startInput && Predicate.isObject(startInput)) {
const startPayload = startInput as {
provider?: string;
providerInstanceId?: ProviderInstanceId;
cwd?: string;
};
assert.equal(startPayload.provider, "claudeAgent");
assert.equal(startPayload.providerInstanceId, claudeAgentInstanceId);
assert.equal(startPayload.cwd, "/tmp/project-claude");
}
}),
);
});
routing.layer("ProviderServiceLive routing", (it) => {
it.effect("lists no sessions after adapter runtime clears", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
yield* provider.startSession(asThreadId("thread-1"), {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId: asThreadId("thread-1"),
runtimeMode: "full-access",
});
yield* provider.startSession(asThreadId("thread-2"), {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId: asThreadId("thread-2"),
runtimeMode: "full-access",
});
yield* routing.codex.stopAll();
yield* routing.claude.stopAll();
const remaining = yield* provider.listSessions();
assert.equal(remaining.length, 0);
}),
);
});
validation.layer("ProviderServiceLive validation", (it) => {
it.effect("returns ProviderValidationError for invalid input payloads", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const failure = yield* Effect.result(
provider.startSession(asThreadId("thread-validation"), {
threadId: asThreadId("thread-validation"),
provider: "invalid-provider",
runtimeMode: "full-access",
} as never),
);
assert.equal(failure._tag, "Failure");
if (!Predicate.isTagged(failure, "Failure")) {
return;
}
assert.equal(failure.failure._tag, "ProviderValidationError");
if (!Predicate.isTagged(failure.failure, "ProviderValidationError")) {
return;
}
assert.equal(failure.failure.operation, "ProviderService.startSession");
assert.equal(failure.failure.issue.includes("invalid-provider"), true);
}),
);
});
validation.layer("ProviderServiceLive validation", (it) => {
it.effect("accepts startSession when adapter has not emitted provider thread id yet", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const runtimeRepository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository;
validation.codex.startSession.mockImplementationOnce((input: ProviderSessionStartInput) =>
Effect.sync(() => {
const now = "2026-01-01T00:00:00.000Z";
return {
provider: ProviderDriverKind.make("codex"),
status: "ready",
threadId: input.threadId,
runtimeMode: input.runtimeMode,
cwd: input.cwd ?? process.cwd(),
createdAt: now,
updatedAt: now,
} satisfies ProviderSession;
}),
);
const session = yield* provider.startSession(asThreadId("thread-missing"), {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId: asThreadId("thread-missing"),
cwd: "/tmp/project",
runtimeMode: "full-access",
});
assert.equal(session.threadId, asThreadId("thread-missing"));
const runtime = yield* runtimeRepository.getByThreadId({
threadId: session.threadId,
});
assert.equal(Option.isSome(runtime), true);
if (Option.isSome(runtime)) {
assert.equal(runtime.value.threadId, session.threadId);
}
}),
);
});
boundedListing.layer("ProviderServiceLive session listing", (it) => {
it.effect("looks up bindings for active sessions without scanning historical threads", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
yield* boundedListing.codex.startSession({
provider: CODEX_DRIVER,
providerInstanceId: codexInstanceId,
threadId: activeSessionThreadId,
cwd: "/tmp/project-active-session",
runtimeMode: "full-access",
});
listThreadIds.mockClear();
getBinding.mockClear();
const sessions = yield* provider.listSessions();
assert.equal(sessions.length, 1);
assert.equal(listThreadIds.mock.calls.length, 0);
assert.deepEqual(getBinding.mock.calls, [[activeSessionThreadId]]);
}),
);
});