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_PROVIDER_INTERACTION_MODE, DEFAULT_RUNTIME_MODE } from "./orchestration.ts";
import { ProviderInstanceId } from "./providerInstance.ts";
import {
decodeProjectCreateCommand,
decodeProjectMetaUpdatedPayload,
decodeThreadTurnStartCommand,
decodeClientOrchestrationCommand,
decodeOrchestrationSession,
encodeThreadCreatedPayload,
decodeThreadCreatedPayload,
decodeOrchestrationCommand,
decodeThreadMetaUpdatedPayload,
decodeModelSelection,
encodeModelSelection,
} from "./orchestration.test-support.ts";
it.effect("decodes WhatsApp message origins", () =>
Effect.gen(function* () {
const command = yield* decodeOrchestrationCommand({
type: "thread.turn.start",
commandId: "turn-whatsapp",
threadId: "thread-whatsapp",
message: {
messageId: "message-whatsapp",
role: "user",
text: "Hello",
attachments: [],
channelOrigin: {
provider: "whatsapp",
externalThreadId: "whatsapp:phone:user",
externalMessageId: "wamid.1",
externalSenderId: "user",
},
},
runtimeMode: "full-access",
interactionMode: "default",
createdAt: "2026-08-27T20:00:00.000Z",
});
assert.equal(command.type, "thread.turn.start");
if (command.type !== "thread.turn.start") return;
assert.deepEqual(command.message.channelOrigin, {
provider: "whatsapp",
externalThreadId: "whatsapp:phone:user",
externalMessageId: "wamid.1",
externalSenderId: "user",
});
}),
);
it.effect("requires credentials for the selected iMessage mode", () =>
Effect.gen(function* () {
const missingHosted = yield* Effect.exit(
decodeClientOrchestrationCommand({
type: "channel.connect",
commandId: "connect-imessage-hosted",
botId: "bot-1",
targetProjectId: "project-1",
provider: "imessage",
mode: "hosted",
}),
);
const missingSelfHosted = yield* Effect.exit(
decodeClientOrchestrationCommand({
type: "channel.connect",
commandId: "connect-imessage-self-hosted",
botId: "bot-1",
targetProjectId: "project-1",
provider: "imessage",
mode: "self-hosted",
}),
);
assert.strictEqual(missingHosted._tag, "Failure");
assert.strictEqual(missingSelfHosted._tag, "Failure");
}),
);
it.effect("trims branded ids and command string fields at decode boundaries", () =>
Effect.gen(function* () {
const parsed = yield* decodeProjectCreateCommand({
type: "project.create",
commandId: " cmd-1 ",
projectId: " project-1 ",
title: " Project Title ",
workspaceRoot: " /tmp/workspace ",
defaultModelSelection: {
provider: "codex",
model: " gpt-5.2 ",
},
createdAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.commandId, "cmd-1");
assert.strictEqual(parsed.projectId, "project-1");
assert.strictEqual(parsed.title, "Project Title");
assert.strictEqual(parsed.workspaceRoot, "/tmp/workspace");
assert.strictEqual(parsed.createWorkspaceRootIfMissing, undefined);
assert.deepStrictEqual(parsed.defaultModelSelection, {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.2",
});
}),
);
it.effect("decodes project.create with createWorkspaceRootIfMissing enabled", () =>
Effect.gen(function* () {
const parsed = yield* decodeProjectCreateCommand({
type: "project.create",
commandId: "cmd-1",
projectId: "project-1",
title: "Project Title",
workspaceRoot: "/tmp/workspace",
createWorkspaceRootIfMissing: true,
createdAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.createWorkspaceRootIfMissing, true);
}),
);
it.effect("decodes project.meta-updated payloads with explicit default provider", () =>
Effect.gen(function* () {
const parsed = yield* decodeProjectMetaUpdatedPayload({
projectId: "project-1",
defaultModelSelection: {
provider: "claudeAgent",
model: "claude-opus-4-6",
},
updatedAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.defaultModelSelection?.instanceId, "claudeAgent");
}),
);
it.effect("rejects command fields that become empty after trim", () =>
Effect.gen(function* () {
const result = yield* Effect.exit(
decodeProjectCreateCommand({
type: "project.create",
commandId: "cmd-1",
projectId: "project-1",
title: " ",
workspaceRoot: "/tmp/workspace",
createdAt: "2026-01-01T00:00:00.000Z",
}),
);
assert.strictEqual(result._tag, "Failure");
}),
);
it.effect("preserves explicit provider and runtime mode in thread.turn.start", () =>
Effect.gen(function* () {
const parsed = yield* decodeThreadTurnStartCommand({
type: "thread.turn.start",
commandId: "cmd-turn-2",
threadId: "thread-1",
message: {
messageId: "msg-2",
role: "user",
text: "hello",
attachments: [],
},
modelSelection: {
provider: "codex",
model: "gpt-5.4",
},
runtimeMode: "full-access",
createdAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.modelSelection?.instanceId, "codex");
assert.strictEqual(parsed.runtimeMode, "full-access");
assert.strictEqual(parsed.interactionMode, DEFAULT_PROVIDER_INTERACTION_MODE);
}),
);
it.effect("decodes thread.meta-updated payloads with explicit provider", () =>
Effect.gen(function* () {
const parsed = yield* decodeThreadMetaUpdatedPayload({
threadId: "thread-1",
regenerateTitle: true,
previousTitle: "Previous title",
titleRegeneration: {
requestId: "cmd-title-regenerate",
startedAt: "2026-01-01T00:00:00.000Z",
},
modelSelection: {
provider: "claudeAgent",
model: "claude-opus-4-6",
},
updatedAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.previousTitle, "Previous title");
assert.strictEqual(parsed.titleRegeneration?.requestId, "cmd-title-regenerate");
assert.strictEqual(parsed.modelSelection?.instanceId, "claudeAgent");
}),
);
it.effect(
"normalizes legacy object-shaped options on decode and re-encodes as canonical array",
() =>
Effect.gen(function* () {
const decoded = yield* decodeThreadCreatedPayload({
threadId: "thread-1",
projectId: "project-1",
title: "Round trip thread",
modelSelection: {
provider: "codex",
model: "gpt-5.4",
options: { fastMode: true },
},
branch: null,
worktreePath: null,
createdAt: "2026-01-01T00:00:00.000Z",
updatedAt: "2026-01-01T00:00:00.000Z",
});
const encoded = yield* encodeThreadCreatedPayload(decoded);
assert.deepStrictEqual(encoded.modelSelection.options, [{ id: "fastMode", value: true }]);
}),
);
it.effect("decodes orchestration session runtime mode defaults", () =>
Effect.gen(function* () {
const parsed = yield* decodeOrchestrationSession({
threadId: "thread-1",
status: "idle",
providerName: null,
providerSessionId: null,
providerThreadId: null,
activeTurnId: null,
lastError: null,
updatedAt: "2026-01-01T00:00:00.000Z",
});
assert.strictEqual(parsed.runtimeMode, DEFAULT_RUNTIME_MODE);
}),
);
it.effect("ModelSelection accepts an explicit instanceId routing key", () =>
Effect.gen(function* () {
const parsed = yield* decodeModelSelection({
instanceId: "codex_personal",
model: "gpt-5-codex",
});
assert.strictEqual(parsed.instanceId, ProviderInstanceId.make("codex_personal"));
}),
);
it.effect("ModelSelection prefers explicit instanceId over legacy provider", () =>
Effect.gen(function* () {
const parsed = yield* decodeModelSelection({
provider: "codex",
instanceId: "codex_personal",
model: "gpt-5-codex",
});
assert.strictEqual(parsed.instanceId, ProviderInstanceId.make("codex_personal"));
}),
);
it.effect(
"ModelSelection decodes unknown driver kinds via legacy provider (rollback / fork invariant)",
() =>
Effect.gen(function* () {
const parsed = yield* decodeModelSelection({
provider: "ollama",
model: "llama3:70b",
options: [{ id: "temperature", value: "0.4" }],
});
assert.strictEqual(parsed.instanceId, ProviderInstanceId.make("ollama"));
assert.strictEqual(parsed.model, "llama3:70b");
}),
);
it.effect("ModelSelection encodes to the canonical instanceId wire form", () =>
Effect.gen(function* () {
const decoded = yield* decodeModelSelection({
provider: "ollama",
model: "llama3:70b",
options: [{ id: "temperature", value: "0.4" }],
});
const encoded = yield* encodeModelSelection(decoded);
assert.deepStrictEqual(encoded, {
instanceId: "ollama",
model: "llama3:70b",
options: [{ id: "temperature", value: "0.4" }],
});
}),
);
it.effect("ModelSelection rejects malformed instance ids", () =>
Effect.gen(function* () {
const result = yield* Effect.exit(
decodeModelSelection({
instanceId: "1invalid", // must start with a letter
model: "x",
}),
);
assert.strictEqual(result._tag, "Failure");
}),
);