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 { Predicate } from "effect";
import { describe, expect, it } from "@effect/vitest";
import { EnvironmentNotRegisteredError } from "@akeru/client-runtime/connection";
import { isTransportConnectionErrorMessage } from "@akeru/client-runtime/errors";
import { EnvironmentRpcUnavailableError } from "@akeru/client-runtime/rpc";
import {
EnvironmentAuthorizationError,
EnvironmentId,
OrchestrationDispatchCommandError,
ProjectId,
ProviderInstanceId,
} from "@akeru/contracts";
import * as RpcClientError from "effect/unstable/rpc/RpcClientError";
import * as Socket from "effect/unstable/socket/Socket";
import {
decodeQueuedThreadMessage,
encodeQueuedThreadMessage,
groupQueuedThreadMessages,
isQueuedThreadCreationSendable,
modelSelectionsEqual,
resolveThreadOutboxDeliveryAction,
resolveThreadOutboxFailureAction,
resolveQueuedThreadSettings,
shouldRetryThreadOutboxDelivery,
threadOutboxHydrationRetryDelayMs,
threadOutboxRetryDelayMs,
type QueuedThreadMessage,
} from "./thread-outbox-model";
import { queuedMessage } from "./thread-outbox.test-support";
describe("thread outbox", () => {
it("groups messages by scoped thread and preserves creation order", () => {
const later = queuedMessage({
messageId: "message-2",
createdAt: "2026-06-08T10:00:02.000Z",
});
const earlier = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
expect(groupQueuedThreadMessages([later, earlier])).toEqual({
"environment-1:thread-1": [earlier, later],
});
});
it("decodes the persisted schema and rejects incomplete messages", () => {
const message = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
expect(
decodeQueuedThreadMessage({
schemaVersion: 1,
...message,
}),
).toEqual(message);
expect(() =>
decodeQueuedThreadMessage({
schemaVersion: 1,
environmentId: "environment-1",
}),
).toThrow();
});
it("persists the exact selector snapshot while remaining compatible with v1 messages", () => {
const legacyMessage = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
const selectedMessage = {
...legacyMessage,
modelSelection: {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.4",
options: [{ id: "reasoningEffort", value: "xhigh" }],
},
runtimeMode: "approval-required",
interactionMode: "plan",
} satisfies QueuedThreadMessage;
expect(decodeQueuedThreadMessage(encodeQueuedThreadMessage(selectedMessage))).toEqual(
selectedMessage,
);
expect(
resolveQueuedThreadSettings(legacyMessage, {
modelSelection: selectedMessage.modelSelection,
runtimeMode: selectedMessage.runtimeMode,
interactionMode: selectedMessage.interactionMode,
}),
).toEqual({
modelSelection: selectedMessage.modelSelection,
runtimeMode: selectedMessage.runtimeMode,
interactionMode: selectedMessage.interactionMode,
});
});
it("compares model options as part of the queued settings change", () => {
const base = {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.4",
options: [{ id: "reasoningEffort", value: "medium" }],
} as const;
expect(modelSelectionsEqual(base, base)).toBe(true);
expect(
modelSelectionsEqual(base, {
...base,
options: [{ id: "reasoningEffort", value: "xhigh" }],
}),
).toBe(false);
});
it("backs off queued delivery retries and caps them at sixteen seconds", () => {
expect([1, 2, 3, 4, 5, 6].map(threadOutboxRetryDelayMs)).toEqual([
1_000, 2_000, 4_000, 8_000, 16_000, 16_000,
]);
});
it("only removes a missing-thread message after shell synchronization is live", () => {
expect(
resolveThreadOutboxDeliveryAction({
isCreation: false,
threadExists: false,
shellStatus: "synchronizing",
environmentConnected: true,
threadBusy: false,
}),
).toBe("wait");
expect(
resolveThreadOutboxDeliveryAction({
isCreation: false,
threadExists: false,
shellStatus: "live",
environmentConnected: true,
threadBusy: false,
}),
).toBe("remove");
expect(
resolveThreadOutboxDeliveryAction({
isCreation: false,
threadExists: true,
shellStatus: "live",
environmentConnected: true,
threadBusy: false,
}),
).toBe("send");
});
it("sends existing-thread messages whenever connected so queued messages can steer", () => {
expect(
resolveThreadOutboxDeliveryAction({
isCreation: false,
threadExists: true,
shellStatus: "live",
environmentConnected: true,
threadBusy: true,
}),
).toBe("send");
expect(
resolveThreadOutboxDeliveryAction({
isCreation: false,
threadExists: true,
shellStatus: "live",
environmentConnected: false,
threadBusy: true,
}),
).toBe("wait");
});
it("sends queued creations once connected and live, removing already-created ones", () => {
expect(
resolveThreadOutboxDeliveryAction({
isCreation: true,
threadExists: false,
shellStatus: "cached",
environmentConnected: false,
threadBusy: false,
}),
).toBe("wait");
// Connected but not yet synchronized: a previously delivered creation may
// simply not be visible yet — sending now could duplicate the thread.
expect(
resolveThreadOutboxDeliveryAction({
isCreation: true,
threadExists: false,
shellStatus: "synchronizing",
environmentConnected: true,
threadBusy: false,
}),
).toBe("wait");
expect(
resolveThreadOutboxDeliveryAction({
isCreation: true,
threadExists: false,
shellStatus: "live",
environmentConnected: true,
threadBusy: false,
}),
).toBe("send");
expect(
resolveThreadOutboxDeliveryAction({
isCreation: true,
threadExists: true,
shellStatus: "live",
environmentConnected: true,
threadBusy: true,
}),
).toBe("remove");
});
it("round-trips queued creations and gates incomplete ones from sending", () => {
const base = queuedMessage({
messageId: "message-1",
createdAt: "2026-06-08T10:00:01.000Z",
});
const creationMessage = {
...base,
modelSelection: {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.4",
},
creation: {
projectId: ProjectId.make("project-1"),
workspaceMode: "worktree",
branch: "main",
worktreePath: null,
startFromOrigin: true,
},
} satisfies QueuedThreadMessage;
expect(decodeQueuedThreadMessage(encodeQueuedThreadMessage(creationMessage))).toEqual(
creationMessage,
);
expect(isQueuedThreadCreationSendable(creationMessage)).toBe(true);
expect(
isQueuedThreadCreationSendable({
...creationMessage,
creation: { ...creationMessage.creation, branch: null },
}),
).toBe(false);
expect(
isQueuedThreadCreationSendable({
...creationMessage,
creation: { ...creationMessage.creation, branch: "" },
}),
).toBe(false);
expect(isQueuedThreadCreationSendable({ ...creationMessage, modelSelection: undefined })).toBe(
false,
);
expect(isQueuedThreadCreationSendable(base)).toBe(false);
});
it("retries transport failures but drops deterministic command failures", () => {
expect(shouldRetryThreadOutboxDelivery(new Error("Socket is not connected"))).toBe(true);
expect(
shouldRetryThreadOutboxDelivery({
_tag: "ConnectionTransientError",
message: "temporarily unavailable",
}),
).toBe(true);
expect(shouldRetryThreadOutboxDelivery(new Error("Thread no longer exists"))).toBe(false);
expect(
shouldRetryThreadOutboxDelivery(
new OrchestrationDispatchCommandError({ message: "Thread no longer exists" }),
),
).toBe(false);
expect(
shouldRetryThreadOutboxDelivery(
new EnvironmentAuthorizationError({
message: "Missing scope",
requiredScope: "orchestration:operate",
}),
),
).toBe(false);
});
it("bounds incomplete outbox hydration retries", () => {
expect([0, 1, 2, 3].map(threadOutboxHydrationRetryDelayMs)).toEqual([250, 1_000, 4_000, null]);
});
// A pending task created offline drains the moment the phone reconnects,
// which is exactly when the socket is most likely to drop again. Every way a
// request can fail in flight must retry; a restore turns the pending task
// into a draft and it disappears from the list.
it("retries every in-flight transport failure by tag, not by message text", () => {
const socketReasons = [
new Socket.SocketReadError({ cause: new Error("The network connection was lost.") }),
new Socket.SocketWriteError({ cause: new Error("Broken pipe") }),
new Socket.SocketCloseError({ code: 1006 }),
new Socket.SocketOpenError({ kind: "Timeout", cause: new Error("timeout") }),
];
for (const reason of socketReasons) {
const error = new RpcClientError.RpcClientError({ reason });
expect(isTransportConnectionErrorMessage(error.message)).toBe(
Predicate.isTagged(reason, "SocketCloseError") ||
Predicate.isTagged(reason, "SocketOpenError"),
);
expect(shouldRetryThreadOutboxDelivery(error)).toBe(true);
}
expect(
shouldRetryThreadOutboxDelivery(
new RpcClientError.RpcClientError({
reason: new RpcClientError.RpcClientDefect({
message: "Error decoding message",
cause: new Error("Unexpected end of JSON input"),
}),
}),
),
).toBe(true);
expect(
shouldRetryThreadOutboxDelivery(
new EnvironmentRpcUnavailableError({
environmentId: "environment-1",
message: "Home is not connected.",
}),
),
).toBe(true);
expect(
shouldRetryThreadOutboxDelivery(
new EnvironmentNotRegisteredError({ environmentId: EnvironmentId.make("environment-1") }),
),
).toBe(true);
});
it("retains queued messages when settings synchronization fails before startTurn", () => {
const deterministicFailure = new Error("Thread no longer exists");
expect(
resolveThreadOutboxFailureAction({
stage: "settings-sync",
error: deterministicFailure,
interrupted: false,
}),
).toBe("retry");
expect(
resolveThreadOutboxFailureAction({
stage: "start-turn",
error: deterministicFailure,
interrupted: false,
}),
).toBe("discard");
});
});