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, expect, it } from "@effect/vitest";
import { MessageId } from "@akeru/contracts";
import { AtomRegistry } from "effect/unstable/reactivity";
import type { QueuedThreadMessage } from "./thread-outbox-model";
import { createThreadOutboxManager, ThreadOutboxManagerError } from "./thread-outbox-manager";
import { emptyThreadOutboxLoadResult, type ThreadOutboxStorage } from "./thread-outbox-storage";
import { queuedMessage } from "./thread-outbox.test-support";
describe("thread outbox manager", () => {
it("serializes mutations even when an earlier mutation is slower", async () => {
const registry = AtomRegistry.make();
const manager = createThreadOutboxManager({
registry,
storage: {
load: async () => emptyThreadOutboxLoadResult(),
write: async () => undefined,
remove: async () => undefined,
},
});
const order: string[] = [];
let releaseFirst!: () => void;
const firstBlocked = new Promise<void>((resolve) => {
releaseFirst = resolve;
});
const first = manager.serialize(async () => {
order.push("first:start");
await firstBlocked;
order.push("first:end");
});
const second = manager.serialize(async () => {
order.push("second");
});
await Promise.resolve();
expect(order).toEqual(["first:start"]);
releaseFirst();
await Promise.all([first, second]);
expect(order).toEqual(["first:start", "first:end", "second"]);
registry.dispose();
});
it("holds the mutation queue while persisted messages are loading", async () => {
const registry = AtomRegistry.make();
const message = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
const stored = new Map([[message.messageId, message]]);
let loadCalls = 0;
let removeCalls = 0;
let releaseInitialLoad!: () => void;
const initialLoadBlocked = new Promise<void>((resolve) => {
releaseInitialLoad = resolve;
});
const storage: ThreadOutboxStorage = {
load: async () => {
loadCalls += 1;
if (loadCalls === 1) {
await initialLoadBlocked;
}
return { messages: [...stored.values()], unreadRecords: [] };
},
write: async () => undefined,
remove: async (candidate) => {
removeCalls += 1;
stored.delete(candidate.messageId);
},
};
const manager = createThreadOutboxManager({ registry, storage });
const loading = manager.load();
await Promise.resolve();
const clearing = manager.clearEnvironment(message.environmentId);
await Promise.resolve();
await Promise.resolve();
expect(loadCalls).toBe(1);
expect(removeCalls).toBe(0);
releaseInitialLoad();
await Promise.all([loading, clearing]);
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
registry.dispose();
});
it("reports structured load failures and permits a retry", async () => {
const registry = AtomRegistry.make();
const loadCause = new Error("storage unavailable");
const warnings: Array<{ message: string; error: unknown }> = [];
let loadCalls = 0;
const manager = createThreadOutboxManager({
registry,
storage: {
load: async () => {
loadCalls += 1;
if (loadCalls === 1) throw loadCause;
return emptyThreadOutboxLoadResult();
},
write: async () => undefined,
remove: async () => undefined,
},
warn: (message, error) => warnings.push({ message, error }),
});
await manager.load();
expect(warnings).toEqual([
{
message: "[thread-outbox] failed to load persisted messages",
error: new ThreadOutboxManagerError({
operation: "load",
environmentId: null,
threadId: null,
messageId: null,
cause: loadCause,
}),
},
]);
await manager.load();
expect(loadCalls).toBe(2);
registry.dispose();
});
it("keeps atom state aligned with durable writes and removals", async () => {
const registry = AtomRegistry.make();
const stored = new Map<MessageId, QueuedThreadMessage>();
const removalCause = new Error("remove failed");
let failRemoval = true;
const storage: ThreadOutboxStorage = {
load: async () => ({ messages: [...stored.values()], unreadRecords: [] }),
write: async (message) => {
stored.set(message.messageId, message);
},
remove: async (message) => {
if (failRemoval) {
throw removalCause;
}
stored.delete(message.messageId);
},
};
const manager = createThreadOutboxManager({ registry, storage });
const message = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
await manager.enqueue(message);
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
"environment-1:thread-1": [message],
});
await expect(manager.remove(message)).rejects.toEqual(
new ThreadOutboxManagerError({
operation: "remove",
environmentId: message.environmentId,
threadId: message.threadId,
messageId: message.messageId,
cause: removalCause,
}),
);
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
"environment-1:thread-1": [message],
});
failRemoval = false;
await manager.remove(message);
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
registry.dispose();
});
it("publishes an enqueued message before the durable write resolves", async () => {
const registry = AtomRegistry.make();
let releaseWrite!: () => void;
const writeBlocked = new Promise<void>((resolve) => {
releaseWrite = resolve;
});
const manager = createThreadOutboxManager({
registry,
storage: {
load: async () => emptyThreadOutboxLoadResult(),
write: async () => writeBlocked,
remove: async () => undefined,
},
});
const message = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
const enqueueing = manager.enqueue(message);
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
"environment-1:thread-1": [message],
});
releaseWrite();
await enqueueing;
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
"environment-1:thread-1": [message],
});
registry.dispose();
});
it("rolls an enqueued message back out when the durable write fails", async () => {
const registry = AtomRegistry.make();
const writeCause = new Error("disk full");
const manager = createThreadOutboxManager({
registry,
storage: {
load: async () => emptyThreadOutboxLoadResult(),
write: async () => {
throw writeCause;
},
remove: async () => undefined,
},
});
const message = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
await expect(manager.enqueue(message)).rejects.toEqual(
new ThreadOutboxManagerError({
operation: "enqueue",
environmentId: message.environmentId,
threadId: message.threadId,
messageId: message.messageId,
cause: writeCause,
}),
);
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
registry.dispose();
});
it("keeps a same-id retry queued when the first attempt's write fails", async () => {
const registry = AtomRegistry.make();
let failNextWrite = true;
let releaseFirstWrite!: () => void;
const firstWriteBlocked = new Promise<void>((resolve) => {
releaseFirstWrite = resolve;
});
const manager = createThreadOutboxManager({
registry,
storage: {
load: async () => emptyThreadOutboxLoadResult(),
write: async () => {
if (failNextWrite) {
failNextWrite = false;
await firstWriteBlocked;
throw new Error("disk full");
}
},
remove: async () => undefined,
},
});
const message = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
const retried = { ...message, text: "retried" };
const first = manager.enqueue(message);
const second = manager.enqueue(retried);
releaseFirstWrite();
await expect(first).rejects.toBeInstanceOf(ThreadOutboxManagerError);
await second;
// The failed first attempt must not roll back the retry that replaced it.
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
"environment-1:thread-1": [retried],
});
await expect(manager.confirmQueued(retried)).resolves.toBe(true);
await expect(manager.confirmQueued(message)).resolves.toBe(false);
registry.dispose();
});
it("replaces an existing message when an enqueue retry uses the same id", async () => {
const registry = AtomRegistry.make();
const manager = createThreadOutboxManager({
registry,
storage: {
load: async () => emptyThreadOutboxLoadResult(),
write: async () => undefined,
remove: async () => undefined,
},
});
const message = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
const retried = { ...message, text: "retried" };
await manager.enqueue(message);
await manager.enqueue(retried);
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
"environment-1:thread-1": [retried],
});
registry.dispose();
});
it("updates a queued message in place but never resurrects a removed one", async () => {
const registry = AtomRegistry.make();
const stored = new Map<MessageId, QueuedThreadMessage>();
const storage: ThreadOutboxStorage = {
load: async () => ({ messages: [...stored.values()], unreadRecords: [] }),
write: async (message) => {
stored.set(message.messageId, message);
},
remove: async (message) => {
stored.delete(message.messageId);
},
};
const manager = createThreadOutboxManager({ registry, storage });
const message = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
await manager.enqueue(message);
const edited = { ...message, text: "edited" };
await expect(manager.update(edited)).resolves.toBe(true);
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
"environment-1:thread-1": [edited],
});
expect(stored.get(message.messageId)).toEqual(edited);
await manager.remove(edited);
await expect(manager.update({ ...message, text: "stale flush" })).resolves.toBe(false);
expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
expect(stored.size).toBe(0);
registry.dispose();
});
});