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 { assert, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import {
DEFAULT_LOCAL_EXECUTION_MODE,
DEFAULT_PROVIDER_INTERACTION_MODE,
DEFAULT_RUNTIME_MODE,
} from "./orchestration.ts";
import {
decodeProjectCreatedPayload,
decodeThreadTurnStartCommand,
decodeThreadTurnStartRequestedPayload,
decodeOrchestrationLatestTurn,
decodeOrchestrationReadModel,
decodeOrchestrationShellSnapshot,
decodeOrchestrationThread,
decodeOrchestrationThreadShell,
decodeThreadCreatedPayload,
decodeOrchestrationCommand,
decodeOrchestrationEvent,
} from "./orchestration.test-support.ts";
it.effect("decodes historical project.created payloads with a default provider", () =>
Effect.gen(function* () {
const parsed = yield* decodeProjectCreatedPayload({
projectId: "project-1",
title: "Project Title",
workspaceRoot: "/tmp/workspace",
defaultModelSelection: {
provider: "codex",
model: "gpt-5.4",
},
scripts: [],
createdAt: "2026-01-01T00:00:00.000Z",
updatedAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.defaultModelSelection?.instanceId, "codex");
}),
);
it.effect("decodes thread.turn.start defaults for provider and runtime mode", () =>
Effect.gen(function* () {
const parsed = yield* decodeThreadTurnStartCommand({
type: "thread.turn.start",
commandId: "cmd-turn-1",
threadId: "thread-1",
message: {
messageId: "msg-1",
role: "user",
text: "hello",
attachments: [],
},
createdAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.modelSelection, undefined);
assert.strictEqual(parsed.runtimeMode, DEFAULT_LOCAL_EXECUTION_MODE);
assert.strictEqual(parsed.interactionMode, DEFAULT_PROVIDER_INTERACTION_MODE);
}),
);
it.effect("decodes thread.created runtime mode for historical events", () =>
Effect.gen(function* () {
const parsed = yield* decodeThreadCreatedPayload({
threadId: "thread-1",
projectId: "project-1",
title: "Thread title",
modelSelection: {
provider: "codex",
model: "gpt-5.4",
},
interactionMode: "default",
branch: null,
worktreePath: null,
createdAt: "2026-01-01T00:00:00.000Z",
updatedAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.runtimeMode, DEFAULT_RUNTIME_MODE);
assert.strictEqual(parsed.modelSelection.instanceId, "codex");
}),
);
it.effect("decodes historical thread.created payloads without parent links", () =>
Effect.gen(function* () {
const parsed = yield* decodeThreadCreatedPayload({
threadId: "thread-legacy",
projectId: "project-1",
title: "Legacy thread",
modelSelection: { provider: "codex", model: "gpt-5.4" },
branch: null,
worktreePath: null,
createdAt: "2026-01-01T00:00:00.000Z",
updatedAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.parentThreadId, undefined);
assert.strictEqual(parsed.parentDelegationId, undefined);
}),
);
it.effect("decodes thread archive and unarchive commands", () =>
Effect.gen(function* () {
const archive = yield* decodeOrchestrationCommand({
type: "thread.archive",
commandId: "cmd-archive-1",
threadId: "thread-1",
});
const unarchive = yield* decodeOrchestrationCommand({
type: "thread.unarchive",
commandId: "cmd-unarchive-1",
threadId: "thread-1",
});
assert.strictEqual(archive.type, "thread.archive");
assert.strictEqual(unarchive.type, "thread.unarchive");
}),
);
it.effect("decodes thread settle and unsettle commands", () =>
Effect.gen(function* () {
const settle = yield* decodeOrchestrationCommand({
type: "thread.settle",
commandId: "cmd-settle-1",
threadId: "thread-1",
});
const unsettle = yield* decodeOrchestrationCommand({
type: "thread.unsettle",
commandId: "cmd-unsettle-1",
threadId: "thread-1",
reason: "user",
});
assert.strictEqual(settle.type, "thread.settle");
assert.strictEqual(unsettle.type, "thread.unsettle");
// "activity" is server-owned: it exists on the event, never on the
// command, so a client cannot forge the neutral reset.
const forged = yield* decodeOrchestrationCommand({
type: "thread.unsettle",
commandId: "cmd-unsettle-2",
threadId: "thread-1",
reason: "activity",
}).pipe(Effect.flip);
assert.ok(forged);
}),
);
it.effect("defaults settled fields when decoding historical thread data", () =>
Effect.gen(function* () {
const common = {
id: "thread-1",
projectId: "project-1",
title: "Historical thread",
modelSelection: { provider: "codex", model: "gpt-5.4" },
runtimeMode: "full-access",
interactionMode: "default",
branch: null,
worktreePath: null,
latestTurn: null,
createdAt: "2026-01-01T00:00:00.000Z",
updatedAt: "2026-01-01T00:00:00.000Z",
archivedAt: null,
session: null,
};
const thread = yield* decodeOrchestrationThread({
...common,
deletedAt: null,
messages: [],
proposedPlans: [],
activities: [],
checkpoints: [],
});
const shell = yield* decodeOrchestrationThreadShell({
...common,
latestUserMessageAt: null,
hasPendingApprovals: false,
hasPendingUserInput: false,
hasActionableProposedPlan: false,
});
assert.strictEqual(thread.settledOverride, null);
assert.strictEqual(thread.settledAt, null);
assert.strictEqual(shell.settledOverride, null);
assert.strictEqual(shell.settledAt, null);
}),
);
it.effect("defaults delegations when decoding historical read models", () =>
Effect.gen(function* () {
const readModel = yield* decodeOrchestrationReadModel({
snapshotSequence: 0,
projects: [],
bots: [],
groups: [],
threads: [],
updatedAt: "2026-08-31T12:00:00.000Z",
});
assert.deepEqual(readModel.delegations, []);
}),
);
it.effect("defaults delegations when decoding historical shell snapshots", () =>
Effect.gen(function* () {
const snapshot = yield* decodeOrchestrationShellSnapshot({
snapshotSequence: 1,
projects: [],
threads: [],
updatedAt: "2026-08-31T00:00:00.000Z",
});
assert.deepEqual(snapshot.delegations, []);
}),
);
it.effect("decodes thread archived and unarchived events", () =>
Effect.gen(function* () {
const archived = yield* decodeOrchestrationEvent({
sequence: 1,
eventId: "event-archive-1",
aggregateKind: "thread",
aggregateId: "thread-1",
type: "thread.archived",
occurredAt: "2026-01-01T00:00:00.000Z",
commandId: "cmd-archive-1",
causationEventId: null,
correlationId: "cmd-archive-1",
metadata: {},
payload: {
threadId: "thread-1",
archivedAt: "2026-01-01T00:00:00.000Z",
updatedAt: "2026-01-01T00:00:00.000Z",
},
});
const unarchived = yield* decodeOrchestrationEvent({
sequence: 2,
eventId: "event-unarchive-1",
aggregateKind: "thread",
aggregateId: "thread-1",
type: "thread.unarchived",
occurredAt: "2026-01-02T00:00:00.000Z",
commandId: "cmd-unarchive-1",
causationEventId: null,
correlationId: "cmd-unarchive-1",
metadata: {},
payload: {
threadId: "thread-1",
updatedAt: "2026-01-02T00:00:00.000Z",
},
});
if (archived.type !== "thread.archived") {
assert.fail(`Expected thread.archived event, received ${archived.type}.`);
}
assert.strictEqual(archived.payload.archivedAt, "2026-01-01T00:00:00.000Z");
assert.strictEqual(unarchived.type, "thread.unarchived");
}),
);
it.effect("decodes thread settled and unsettled events", () =>
Effect.gen(function* () {
const settled = yield* decodeOrchestrationEvent({
sequence: 1,
eventId: "event-settle-1",
aggregateKind: "thread",
aggregateId: "thread-1",
type: "thread.settled",
occurredAt: "2026-01-01T00:00:00.000Z",
commandId: "cmd-settle-1",
causationEventId: null,
correlationId: "cmd-settle-1",
metadata: {},
payload: {
threadId: "thread-1",
settledAt: "2026-01-01T00:00:00.000Z",
updatedAt: "2026-01-01T00:00:00.000Z",
},
});
const unsettled = yield* decodeOrchestrationEvent({
sequence: 2,
eventId: "event-unsettle-1",
aggregateKind: "thread",
aggregateId: "thread-1",
type: "thread.unsettled",
occurredAt: "2026-01-02T00:00:00.000Z",
commandId: "cmd-unsettle-1",
causationEventId: null,
correlationId: "cmd-unsettle-1",
metadata: {},
payload: {
threadId: "thread-1",
reason: "user",
updatedAt: "2026-01-02T00:00:00.000Z",
},
});
assert.strictEqual(settled.type, "thread.settled");
assert.strictEqual(unsettled.type, "thread.unsettled");
}),
);
it.effect(
"decodes thread.turn-start-requested defaults for provider, runtime mode, and interaction mode",
() =>
Effect.gen(function* () {
const parsed = yield* decodeThreadTurnStartRequestedPayload({
threadId: "thread-1",
messageId: "msg-1",
createdAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.modelSelection, undefined);
assert.strictEqual(parsed.runtimeMode, DEFAULT_RUNTIME_MODE);
assert.strictEqual(parsed.interactionMode, DEFAULT_PROVIDER_INTERACTION_MODE);
assert.strictEqual(parsed.sourceProposedPlan, undefined);
}),
);
it.effect("decodes historical latest turns without a request message id", () =>
Effect.gen(function* () {
const parsed = yield* decodeOrchestrationLatestTurn({
turnId: "turn-2",
state: "running",
requestedAt: "2026-01-01T00:00:00.000Z",
startedAt: null,
completedAt: null,
assistantMessageId: null,
});
assert.strictEqual(parsed.requestMessageId, undefined);
}),
);