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 { ProviderRuntimeEvent } from "@akeru/contracts";
import { ProviderDriverKind } from "@akeru/contracts";
import { it, assert } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Ref from "effect/Ref";
import * as Stream from "effect/Stream";
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,
asEventId,
asThreadId,
asTurnId,
codexInstanceId,
type LegacyProviderRuntimeEvent,
makeFakeCodexAdapter,
advanceTestClock,
makeProviderServiceHarness,
} from "./test-support/providerServiceHarness.ts";
const { fanout } = makeProviderServiceHarness();
it.effect("ProviderServiceLive writes canonical events to the emitting thread segment", () =>
Effect.gen(function* () {
const codex = makeFakeCodexAdapter();
const canonicalEvents: ProviderRuntimeEvent[] = [];
const canonicalThreadIds: Array<string | null> = [];
const registry = adapterRegistryMock({
[ProviderDriverKind.make("codex")]: codex.adapter,
});
const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
Layer.provide(SqlitePersistenceMemory),
);
const directoryLayer = ProviderSessionDirectoryLive.pipe(Layer.provide(runtimeRepositoryLayer));
const providerLayer = providerServiceLayerWith({
canonicalEventLogger: {
filePath: "memory://provider-canonical-events",
write: (event, threadId) => {
canonicalEvents.push(event as ProviderRuntimeEvent);
canonicalThreadIds.push(threadId ?? null);
return Effect.void;
},
close: () => Effect.void,
},
}).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* () {
yield* ProviderService.ProviderService;
yield* advanceTestClock(10);
codex.emit({
eventId: asEventId("evt-canonical-thread-segment"),
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-canonical-thread-segment"),
createdAt: "2026-01-01T00:00:00.000Z",
type: "turn.completed",
payload: {
state: "completed",
},
});
yield* advanceTestClock(20);
}).pipe(Effect.provide(providerLayer));
assert.equal(canonicalEvents.length, 1);
assert.equal(canonicalEvents[0]?.threadId, "thread-canonical-thread-segment");
assert.deepEqual(canonicalThreadIds, ["thread-canonical-thread-segment"]);
}).pipe(Effect.provide(NodeServices.layer)),
);
fanout.layer("ProviderServiceLive fanout", (it) => {
it.effect("fans out adapter turn completion events", () =>
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"),
runtimeMode: "full-access",
});
const eventsRef = yield* Ref.make<Array<ProviderRuntimeEvent>>([]);
const consumer = yield* Stream.runForEach(provider.streamEvents, (event) =>
Ref.update(eventsRef, (current) => [...current, event]),
).pipe(Effect.forkChild);
yield* advanceTestClock(50);
const completedEvent: LegacyProviderRuntimeEvent = {
type: "turn.completed",
eventId: asEventId("evt-1"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: session.threadId,
turnId: asTurnId("turn-1"),
status: "completed",
};
fanout.codex.emit(completedEvent);
yield* advanceTestClock(50);
const events = yield* Ref.get(eventsRef);
yield* Fiber.interrupt(consumer);
assert.equal(
events.some((entry) => entry.type === "turn.completed"),
true,
);
assert.equal(
events.some(
(entry) =>
entry.type === "turn.completed" && entry.providerInstanceId === codexInstanceId,
),
true,
);
}),
);
});
fanout.layer("ProviderServiceLive fanout", (it) => {
it.effect("fans out canonical runtime events in emission order", () =>
Effect.gen(function* () {
const provider = yield* ProviderService.ProviderService;
const session = yield* provider.startSession(asThreadId("thread-seq"), {
provider: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
threadId: asThreadId("thread-seq"),
runtimeMode: "full-access",
});
const receivedRef = yield* Ref.make<Array<ProviderRuntimeEvent>>([]);
const consumer = yield* Stream.take(provider.streamEvents, 3).pipe(
Stream.runForEach((event) => Ref.update(receivedRef, (current) => [...current, event])),
Effect.forkChild,
);
yield* advanceTestClock(50);
fanout.codex.emit({
type: "tool.started",
eventId: asEventId("evt-seq-1"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: session.threadId,
turnId: asTurnId("turn-1"),
toolKind: "command",
title: "Ran command",
});
fanout.codex.emit({
type: "tool.completed",
eventId: asEventId("evt-seq-2"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: session.threadId,
turnId: asTurnId("turn-1"),
toolKind: "command",
title: "Ran command",
});
fanout.codex.emit({
type: "turn.completed",
eventId: asEventId("evt-seq-3"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: session.threadId,
turnId: asTurnId("turn-1"),
status: "completed",
});
yield* Fiber.join(consumer);
const received = yield* Ref.get(receivedRef);
assert.deepEqual(
received.map((event) => event.eventId),
[asEventId("evt-seq-1"), asEventId("evt-seq-2"), asEventId("evt-seq-3")],
);
}),
);
});
fanout.layer("ProviderServiceLive fanout", (it) => {
it.effect("keeps subscriber delivery ordered and isolates failing subscribers", () =>
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"),
runtimeMode: "full-access",
});
const receivedByHealthy: string[] = [];
const expectedEventIds = new Set<string>(["evt-ordered-1", "evt-ordered-2", "evt-ordered-3"]);
const healthyFiber = yield* Stream.take(provider.streamEvents, 3).pipe(
Stream.runForEach((event) =>
Effect.sync(() => {
receivedByHealthy.push(event.eventId);
}),
),
Effect.forkChild,
);
const failingFiber = yield* Stream.take(provider.streamEvents, 1).pipe(
Stream.runForEach(() => Effect.fail("listener crash")),
Effect.forkChild,
);
yield* advanceTestClock(50);
const events: ReadonlyArray<LegacyProviderRuntimeEvent> = [
{
type: "tool.completed",
eventId: asEventId("evt-ordered-1"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: session.threadId,
turnId: asTurnId("turn-1"),
toolKind: "command",
title: "Ran command",
detail: "echo one",
},
{
type: "message.delta",
eventId: asEventId("evt-ordered-2"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: session.threadId,
turnId: asTurnId("turn-1"),
delta: "hello",
},
{
type: "turn.completed",
eventId: asEventId("evt-ordered-3"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: session.threadId,
turnId: asTurnId("turn-1"),
status: "completed",
},
];
for (const event of events) {
fanout.codex.emit(event);
}
const failingResult = yield* Effect.result(Fiber.join(failingFiber));
assert.equal(failingResult._tag, "Failure");
yield* Fiber.join(healthyFiber);
assert.deepEqual(
receivedByHealthy.filter((eventId) => expectedEventIds.has(eventId)).slice(0, 3),
["evt-ordered-1", "evt-ordered-2", "evt-ordered-3"],
);
}),
);
});