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 OrchestrationThread } from "@akeru/contracts";
import { describe, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as TestClock from "effect/testing/TestClock";
import {
CACHED_SNAPSHOT_SEQUENCE,
BASE_THREAD,
awaitThreadState,
makeHarness,
snapshot,
synchronized,
titleUpdated,
} from "./threads-sync.test-support.ts";
describe("EnvironmentThreads", () => {
it.effect("seeds the thread from the HTTP snapshot and resumes live events", () =>
Effect.gen(function* () {
const httpThread: OrchestrationThread = { ...BASE_THREAD, title: "HTTP title" };
const harness = yield* makeHarness({
httpSnapshot: Option.some({ snapshotSequence: 1, thread: httpThread }),
});
// No socket snapshot is pushed; only a live event arrives over the socket.
// It can only be applied if the HTTP snapshot already seeded the thread.
yield* Queue.offer(harness.inputs, titleUpdated("Live title", 2));
const state = yield* awaitThreadState(
harness.observed,
(value) =>
value.status === "live" &&
Option.isSome(value.data) &&
value.data.value.title === "Live title",
);
expect(Option.getOrThrow(state.data).title).toBe("Live title");
// Cold cache: the full snapshot was loaded over HTTP and the socket
// resumed from that snapshot's sequence.
expect(yield* Ref.get(harness.loaderCalls)).toBeGreaterThanOrEqual(1);
expect(yield* Ref.get(harness.lastSubscribeAfterSequence)).toBe(1);
}),
);
it.effect("ignores replayed thread events at or below the snapshot sequence", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({ cached: BASE_THREAD });
yield* Queue.offer(harness.inputs, snapshot(BASE_THREAD));
yield* Queue.offer(harness.inputs, titleUpdated("Replayed title", 1));
yield* Queue.offer(harness.inputs, titleUpdated("Live title", 2));
const state = yield* awaitThreadState(
harness.observed,
(value) =>
value.status === "live" &&
Option.isSome(value.data) &&
value.data.value.title === "Live title",
);
expect(Option.getOrThrow(state.data).title).toBe("Live title");
}),
);
it.effect("preserves data after a domain failure and resumes on a replacement session", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({ cached: BASE_THREAD });
yield* Queue.offer(harness.inputs, snapshot(BASE_THREAD));
yield* Queue.offer(harness.inputs, new Error("stream failed"));
const state = yield* awaitThreadState(harness.observed, (value) =>
Option.isSome(value.error),
);
expect(Option.getOrThrow(state.data)).toEqual(BASE_THREAD);
expect(Option.getOrThrow(state.error)).toBe("stream failed");
expect(yield* Ref.get(harness.retryCount)).toBe(0);
yield* harness.replaceSession;
for (let attempt = 0; attempt < 100; attempt += 1) {
if ((yield* Ref.get(harness.subscriptionCount)) >= 2) {
break;
}
yield* Effect.yieldNow;
}
yield* Queue.offer(
harness.inputs,
snapshot({
...BASE_THREAD,
title: "Recovered thread",
}),
);
const recovered = yield* awaitThreadState(
harness.observed,
(value) =>
value.status === "live" &&
Option.isSome(value.data) &&
value.data.value.title === "Recovered thread",
);
expect(Option.isNone(recovered.error)).toBe(true);
expect(yield* Ref.get(harness.subscriptionCount)).toBe(2);
}),
);
it.effect("uses a chat fallback when a stream failure has no message", () =>
Effect.gen(function* () {
const harness = yield* makeHarness();
yield* Queue.offer(harness.inputs, new Error(" "));
const failed = yield* awaitThreadState(harness.observed, (value) =>
Option.isSome(value.error),
);
expect(Option.getOrThrow(failed.error)).toBe("Could not synchronize the chat.");
}),
);
it.effect("recovers from a transient domain failure without replacing the session", () =>
Effect.gen(function* () {
const harness = yield* makeHarness();
yield* Queue.offer(harness.inputs, new Error("thread not found yet"));
const failed = yield* awaitThreadState(harness.observed, (value) =>
Option.isSome(value.error),
);
expect(Option.getOrThrow(failed.error)).toBe("thread not found yet");
expect(yield* Ref.get(harness.subscriptionCount)).toBe(1);
yield* TestClock.adjust("250 millis");
for (let attempt = 0; attempt < 100; attempt += 1) {
if ((yield* Ref.get(harness.subscriptionCount)) >= 2) {
break;
}
yield* Effect.yieldNow;
}
yield* Queue.offer(
harness.inputs,
snapshot({
...BASE_THREAD,
title: "Materialized thread",
}),
);
const recovered = yield* awaitThreadState(
harness.observed,
(value) =>
value.status === "live" &&
Option.isSome(value.data) &&
value.data.value.title === "Materialized thread",
);
expect(Option.isNone(recovered.error)).toBe(true);
expect(yield* Ref.get(harness.subscriptionCount)).toBe(2);
expect(yield* Ref.get(harness.retryCount)).toBe(0);
}),
);
it.effect("keeps replayed updates synchronizing until the completion marker arrives", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({ cached: BASE_THREAD, completionMarker: true });
yield* awaitThreadState(
harness.observed,
(value) => value.status === "synchronizing" && Option.isSome(value.data),
);
expect(yield* Ref.get(harness.lastRequestCompletionMarker)).toBe(true);
yield* Queue.offer(
harness.inputs,
titleUpdated("Caught-up title", CACHED_SNAPSHOT_SEQUENCE + 1),
);
const catchingUp = yield* awaitThreadState(
harness.observed,
(value) =>
value.status === "synchronizing" &&
Option.isSome(value.data) &&
value.data.value.title === "Caught-up title",
);
expect(catchingUp.status).toBe("synchronizing");
yield* Queue.offer(harness.inputs, synchronized());
const live = yield* awaitThreadState(
harness.observed,
(value) => value.status === "live" && Option.isSome(value.data),
);
expect(Option.getOrThrow(live.data).title).toBe("Caught-up title");
}),
);
it.effect("resumes replacement sessions from the latest applied sequence", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({ cached: BASE_THREAD, completionMarker: true });
yield* Queue.offer(
harness.inputs,
titleUpdated("Latest title", CACHED_SNAPSHOT_SEQUENCE + 1),
);
yield* Queue.offer(harness.inputs, synchronized());
yield* awaitThreadState(
harness.observed,
(value) =>
value.status === "live" &&
Option.isSome(value.data) &&
value.data.value.title === "Latest title",
);
yield* harness.replaceSession;
for (let attempt = 0; attempt < 100; attempt += 1) {
if ((yield* Ref.get(harness.subscriptionCount)) >= 2) break;
yield* Effect.yieldNow;
}
expect(yield* Ref.get(harness.subscriptionCount)).toBe(2);
expect(yield* Ref.get(harness.lastSubscribeAfterSequence)).toBe(CACHED_SNAPSHOT_SEQUENCE + 1);
expect((yield* Ref.get(harness.latest)).status).toBe("synchronizing");
}),
);
it.effect("resubscribes on app foreground from the latest applied sequence", () =>
Effect.gen(function* () {
const harness = yield* makeHarness({ cached: BASE_THREAD, completionMarker: true });
yield* Queue.offer(
harness.inputs,
titleUpdated("Latest title", CACHED_SNAPSHOT_SEQUENCE + 1),
);
yield* Queue.offer(harness.inputs, synchronized());
yield* awaitThreadState(
harness.observed,
(value) =>
value.status === "live" &&
Option.isSome(value.data) &&
value.data.value.title === "Latest title",
);
yield* Queue.offer(harness.wakeups, "application-active");
const synchronizing = yield* awaitThreadState(
harness.observed,
(value) => value.status === "synchronizing" && Option.isSome(value.data),
);
for (let attempt = 0; attempt < 100; attempt += 1) {
if ((yield* Ref.get(harness.subscriptionCount)) >= 2) break;
yield* Effect.yieldNow;
}
expect(synchronizing.status).toBe("synchronizing");
expect(yield* Ref.get(harness.subscriptionCount)).toBe(2);
expect(yield* Ref.get(harness.lastSubscribeAfterSequence)).toBe(CACHED_SNAPSHOT_SEQUENCE + 1);
expect(yield* Ref.get(harness.lastRequestCompletionMarker)).toBe(true);
expect(yield* Ref.get(harness.loaderCalls)).toBe(0);
yield* Queue.offer(harness.inputs, synchronized());
const live = yield* awaitThreadState(
harness.observed,
(value) => value.status === "live" && Option.isSome(value.data),
);
expect(Option.getOrThrow(live.data).title).toBe("Latest title");
yield* Queue.offer(harness.wakeups, "application-active-probe");
for (let attempt = 0; attempt < 100; attempt += 1) {
if ((yield* Ref.get(harness.subscriptionCount)) >= 3) break;
yield* Effect.yieldNow;
}
expect(yield* Ref.get(harness.subscriptionCount)).toBe(3);
yield* Queue.offer(harness.wakeups, "application-active-reconnect");
for (let attempt = 0; attempt < 10; attempt += 1) {
yield* Effect.yieldNow;
}
expect(yield* Ref.get(harness.subscriptionCount)).toBe(3);
}),
);
});