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 { describe, it, assert } from "@effect/vitest";
import {
DEFAULT_SERVER_SETTINGS,
ProviderDriverKind,
ProviderInstanceId,
type ServerProvider,
} from "@akeru/contracts";
import { createModelCapabilities } from "@akeru/shared/model";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as PubSub from "effect/PubSub";
import * as Ref from "effect/Ref";
import * as Stream from "effect/Stream";
import { TestClock } from "effect/testing";
import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
import { ServerSettingsService } from "../serverSettings.ts";
import { makeManagedServerProvider } from "./makeManagedServerProvider.ts";
const emptyCapabilities = createModelCapabilities({ optionDescriptors: [] });
const TEST_EPOCH = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z");
const fastModeCapabilities = createModelCapabilities({
optionDescriptors: [
{
id: "fastMode",
label: "Fast Mode",
type: "boolean",
},
],
});
interface TestSettings {
readonly enabled: boolean;
}
const maintenanceCapabilities = {
provider: ProviderDriverKind.make("codex"),
packageName: "@openai/codex",
update: {
command: "npm install -g @openai/codex@latest",
executable: "npm",
args: ["install", "-g", "@openai/codex@latest"],
lockKey: "npm-global",
},
} as const;
const initialSnapshot: ServerProvider = {
instanceId: ProviderInstanceId.make("codex"),
driver: ProviderDriverKind.make("codex"),
enabled: true,
installed: true,
version: null,
status: "warning",
auth: { status: "unknown" },
checkedAt: "2026-04-10T00:00:00.000Z",
message: "Checking provider availability...",
models: [],
slashCommands: [],
skills: [],
};
const refreshedSnapshot: ServerProvider = {
instanceId: ProviderInstanceId.make("codex"),
driver: ProviderDriverKind.make("codex"),
enabled: true,
installed: true,
version: "1.0.0",
status: "ready",
auth: { status: "authenticated" },
checkedAt: "2026-04-10T00:00:01.000Z",
models: [],
slashCommands: [],
skills: [],
};
const enrichedSnapshot: ServerProvider = {
...refreshedSnapshot,
checkedAt: "2026-04-10T00:00:02.000Z",
models: [
{
slug: "composer-2",
name: "Composer 2",
isCustom: false,
capabilities: fastModeCapabilities,
},
],
};
const refreshedSnapshotSecond: ServerProvider = {
...refreshedSnapshot,
checkedAt: "2026-04-10T00:00:03.000Z",
message: "Refreshed provider availability again.",
};
function makeBackgroundPolicyLayer(shouldRunScopeWork: boolean) {
return Layer.mock(BackgroundPolicy.BackgroundPolicy)({
reportClientActivity: () => Effect.void,
removeRpcClient: () => Effect.void,
reportHostPowerState: () => Effect.void,
snapshot: Effect.succeed({
hostPower: {
source: "unknown",
idle: "unknown",
idleSeconds: null,
locked: "unknown",
suspended: false,
onBattery: "unknown",
lowPowerMode: "unknown",
thermalState: "unknown",
stale: true,
updatedAt: TEST_EPOCH,
},
leases: [],
activeForegroundLeaseCount: 0,
activeScopeKeys: [],
shouldRunOpportunisticWork: true,
updatedAt: TEST_EPOCH,
}),
streamChanges: Stream.empty,
hasDemand: () => Effect.succeed(shouldRunScopeWork),
shouldRunScopeWork: () => Effect.succeed(shouldRunScopeWork),
shouldRunOpportunisticWork: Effect.succeed(shouldRunScopeWork),
});
}
const BackgroundPolicyAlwaysRunLayer = makeBackgroundPolicyLayer(true);
const BackgroundPolicyNeverRunLayer = makeBackgroundPolicyLayer(false);
const ServerSettingsTestLayer = ServerSettingsService.layerTest();
const AlwaysRunTestLayer = Layer.merge(BackgroundPolicyAlwaysRunLayer, ServerSettingsTestLayer);
const NeverRunTestLayer = Layer.merge(BackgroundPolicyNeverRunLayer, ServerSettingsTestLayer);
const enrichedSnapshotSecond: ServerProvider = {
...refreshedSnapshotSecond,
checkedAt: "2026-04-10T00:00:04.000Z",
models: [
{
slug: "gpt-5.4",
name: "GPT-5.4",
isCustom: false,
capabilities: emptyCapabilities,
},
],
};
describe("makeManagedServerProvider", () => {
it.effect(
"runs the initial provider check in the background and streams the refreshed snapshot",
() =>
Effect.scoped(
Effect.gen(function* () {
const checkCalls = yield* Ref.make(0);
const releaseCheck = yield* Deferred.make<void>();
const provider = yield* makeManagedServerProvider<TestSettings>({
maintenanceCapabilities,
getSettings: Effect.succeed({ enabled: true }),
streamSettings: Stream.empty,
haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
initialSnapshot: () => Effect.succeed(initialSnapshot),
checkProvider: Ref.update(checkCalls, (count) => count + 1).pipe(
Effect.flatMap(() => Deferred.await(releaseCheck)),
Effect.as(refreshedSnapshot),
),
refreshInterval: "1 hour",
});
const initial = yield* provider.getSnapshot;
assert.deepStrictEqual(initial, initialSnapshot);
const updatesFiber = yield* Stream.take(provider.streamChanges, 1).pipe(
Stream.runCollect,
Effect.forkChild,
);
yield* Effect.yieldNow;
assert.strictEqual(yield* Ref.get(checkCalls), 1);
yield* Deferred.succeed(releaseCheck, undefined);
const updates = Array.from(yield* Fiber.join(updatesFiber));
const latest = yield* provider.getSnapshot;
assert.deepStrictEqual(updates, [refreshedSnapshot]);
assert.deepStrictEqual(latest, refreshedSnapshot);
assert.strictEqual(yield* Ref.get(checkCalls), 1);
}),
).pipe(Effect.provide(AlwaysRunTestLayer)),
);
it.effect("skips periodic provider refreshes without foreground provider-status demand", () =>
Effect.scoped(
Effect.gen(function* () {
const checkCalls = yield* Ref.make(0);
const initialCheckDone = yield* Deferred.make<void>();
yield* makeManagedServerProvider<TestSettings>({
maintenanceCapabilities,
getSettings: Effect.succeed({ enabled: true }),
streamSettings: Stream.empty,
haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
initialSnapshot: () => Effect.succeed(initialSnapshot),
checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
Effect.tap((count) =>
count === 1
? Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)
: Effect.void,
),
Effect.as(refreshedSnapshot),
),
refreshInterval: "1 second",
});
yield* Deferred.await(initialCheckDone);
yield* TestClock.adjust("1 second");
yield* Effect.yieldNow;
assert.strictEqual(yield* Ref.get(checkCalls), 1);
}),
).pipe(Effect.provide(Layer.mergeAll(NeverRunTestLayer, TestClock.layer()))),
);
it.effect("disables periodic provider refreshes when the explicit interval is zero", () =>
Effect.scoped(
Effect.gen(function* () {
const checkCalls = yield* Ref.make(0);
const initialCheckDone = yield* Deferred.make<void>();
yield* makeManagedServerProvider<TestSettings>({
maintenanceCapabilities,
getSettings: Effect.succeed({ enabled: true }),
streamSettings: Stream.empty,
haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
initialSnapshot: () => Effect.succeed(initialSnapshot),
checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
Effect.tap(() => Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)),
Effect.as(refreshedSnapshot),
),
refreshInterval: 0,
});
yield* Deferred.await(initialCheckDone);
yield* TestClock.adjust("5 minutes");
yield* Effect.yieldNow;
assert.strictEqual(yield* Ref.get(checkCalls), 1);
}),
).pipe(Effect.provide(Layer.mergeAll(AlwaysRunTestLayer, TestClock.layer()))),
);
it.effect("wakes a sleeping provider refresh loop when its interval changes", () =>
Effect.scoped(
Effect.gen(function* () {
const initialServerSettings = {
...DEFAULT_SERVER_SETTINGS,
providerHealthRefreshInterval: Duration.hours(1),
};
const serverSettingsRef = yield* Ref.make(initialServerSettings);
const serverSettingsChanges = yield* PubSub.unbounded<typeof initialServerSettings>();
const serverSettingsLayer = Layer.succeed(
ServerSettingsService,
ServerSettingsService.of({
start: Effect.void,
ready: Effect.void,
getSettings: Ref.get(serverSettingsRef),
updateSettings: () => Effect.die(new Error("unused in this test")),
streamChanges: Stream.empty,
subscribeChanges: PubSub.subscribe(serverSettingsChanges).pipe(
Effect.map((subscription) => Stream.fromSubscription(subscription)),
),
}),
);
const checkCalls = yield* Ref.make(0);
const initialCheckDone = yield* Deferred.make<void>();
const periodicCheckDone = yield* Deferred.make<void>();
yield* makeManagedServerProvider<TestSettings>({
maintenanceCapabilities,
getSettings: Effect.succeed({ enabled: true }),
streamSettings: Stream.empty,
haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
initialSnapshot: () => Effect.succeed(initialSnapshot),
checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
Effect.tap((count) =>
count === 1
? Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)
: Deferred.succeed(periodicCheckDone, undefined).pipe(Effect.ignore),
),
Effect.as(refreshedSnapshot),
),
}).pipe(Effect.provide(Layer.merge(BackgroundPolicyAlwaysRunLayer, serverSettingsLayer)));
yield* Deferred.await(initialCheckDone);
const nextServerSettings = {
...initialServerSettings,
providerHealthRefreshInterval: Duration.seconds(1),
};
yield* Ref.set(serverSettingsRef, nextServerSettings);
yield* PubSub.publish(serverSettingsChanges, nextServerSettings);
yield* Effect.yieldNow;
yield* TestClock.adjust("999 millis");
assert.strictEqual(yield* Ref.get(checkCalls), 1);
yield* TestClock.adjust("1 millis");
yield* Deferred.await(periodicCheckDone);
assert.strictEqual(yield* Ref.get(checkCalls), 2);
}),
).pipe(Effect.provide(TestClock.layer())),
);
it.effect("reruns the provider check when streamed settings change", () =>
Effect.scoped(
Effect.gen(function* () {
const settingsRef = yield* Ref.make<TestSettings>({ enabled: true });
const settingsChanges = yield* PubSub.unbounded<TestSettings>();
const checkCalls = yield* Ref.make(0);
const releaseInitialCheck = yield* Deferred.make<void>();
const releaseSettingsCheck = yield* Deferred.make<void>();
const provider = yield* makeManagedServerProvider<TestSettings>({
maintenanceCapabilities,
getSettings: Ref.get(settingsRef),
streamSettings: Stream.fromPubSub(settingsChanges),
haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
initialSnapshot: () => Effect.succeed(initialSnapshot),
checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
Effect.flatMap((count) =>
count === 1
? Deferred.await(releaseInitialCheck).pipe(Effect.as(refreshedSnapshot))
: Deferred.await(releaseSettingsCheck).pipe(Effect.as(refreshedSnapshotSecond)),
),
),
refreshInterval: "1 hour",
});
const updatesFiber = yield* Stream.take(provider.streamChanges, 2).pipe(
Stream.runCollect,
Effect.forkChild,
);
yield* Effect.yieldNow;
yield* Deferred.succeed(releaseInitialCheck, undefined);
yield* Ref.set(settingsRef, { enabled: false });
yield* PubSub.publish(settingsChanges, { enabled: false });
yield* Deferred.succeed(releaseSettingsCheck, undefined);
const updates = Array.from(yield* Fiber.join(updatesFiber));
const latest = yield* provider.getSnapshot;
assert.deepStrictEqual(updates, [refreshedSnapshot, refreshedSnapshotSecond]);
assert.deepStrictEqual(latest, refreshedSnapshotSecond);
assert.strictEqual(yield* Ref.get(checkCalls), 2);
}),
).pipe(Effect.provide(AlwaysRunTestLayer)),
);
it.effect("streams supplemental snapshot updates after the base provider check completes", () =>
Effect.scoped(
Effect.gen(function* () {
const releaseEnrichment = yield* Deferred.make<void>();
const releaseCheck = yield* Deferred.make<void>();
const provider = yield* makeManagedServerProvider<TestSettings>({
maintenanceCapabilities,
getSettings: Effect.succeed({ enabled: true }),
streamSettings: Stream.empty,
haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
initialSnapshot: () => Effect.succeed(initialSnapshot),
checkProvider: Deferred.await(releaseCheck).pipe(Effect.as(refreshedSnapshot)),
enrichSnapshot: ({ publishSnapshot }) =>
Deferred.await(releaseEnrichment).pipe(
Effect.flatMap(() => publishSnapshot(enrichedSnapshot)),
),
refreshInterval: "1 hour",
});
const updatesFiber = yield* Stream.take(provider.streamChanges, 2).pipe(
Stream.runCollect,
Effect.forkChild,
);
yield* Effect.yieldNow;
yield* Deferred.succeed(releaseCheck, undefined);
yield* Deferred.succeed(releaseEnrichment, undefined);
const updates = Array.from(yield* Fiber.join(updatesFiber));
const latest = yield* provider.getSnapshot;
assert.deepStrictEqual(updates, [refreshedSnapshot, enrichedSnapshot]);
assert.deepStrictEqual(latest, enrichedSnapshot);
}),
).pipe(Effect.provide(AlwaysRunTestLayer)),
);
it.effect("ignores stale enrichment callbacks after a newer refresh advances generation", () =>
Effect.scoped(
Effect.gen(function* () {
const publishCallbacks: Array<(snapshot: ServerProvider) => Effect.Effect<void>> = [];
const refreshCount = yield* Ref.make(0);
const firstCallbackReady = yield* Deferred.make<void>();
const secondCallbackReady = yield* Deferred.make<void>();
const allowFirstRefresh = yield* Deferred.make<void>();
const provider = yield* makeManagedServerProvider<TestSettings>({
maintenanceCapabilities,
getSettings: Effect.succeed({ enabled: true }),
streamSettings: Stream.empty,
haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
initialSnapshot: () => Effect.succeed(initialSnapshot),
checkProvider: Ref.updateAndGet(refreshCount, (count) => count + 1).pipe(
Effect.flatMap((count) =>
count === 1
? Deferred.await(allowFirstRefresh).pipe(Effect.as(refreshedSnapshot))
: Effect.succeed(refreshedSnapshotSecond),
),
),
enrichSnapshot: ({ publishSnapshot }) =>
Effect.gen(function* () {
publishCallbacks.push(publishSnapshot);
if (publishCallbacks.length === 1) {
yield* Deferred.succeed(firstCallbackReady, undefined).pipe(Effect.ignore);
} else if (publishCallbacks.length === 2) {
yield* Deferred.succeed(secondCallbackReady, undefined).pipe(Effect.ignore);
}
}),
refreshInterval: "1 hour",
});
const updatesFiber = yield* Stream.take(provider.streamChanges, 3).pipe(
Stream.runCollect,
Effect.forkChild,
);
yield* Effect.yieldNow;
yield* Deferred.succeed(allowFirstRefresh, undefined);
yield* Deferred.await(firstCallbackReady);
yield* provider.refresh;
yield* Deferred.await(secondCallbackReady);
yield* publishCallbacks[0]!(enrichedSnapshot);
yield* publishCallbacks[1]!(enrichedSnapshotSecond);
const updates = Array.from(yield* Fiber.join(updatesFiber));
const latest = yield* provider.getSnapshot;
assert.deepStrictEqual(updates, [
refreshedSnapshot,
refreshedSnapshotSecond,
enrichedSnapshotSecond,
]);
assert.deepStrictEqual(latest, enrichedSnapshotSecond);
}),
).pipe(Effect.provide(AlwaysRunTestLayer)),
);
});