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 { Schema } from "effect";
import { makeMobileServerConfig } from "./mobile-fixtures.test-support";
import { describe, expect, it } from "vite-plus/test";
import { catalogRegistry, createTranslator } from "@akeru/client-runtime/i18n";
import {
ServerProvider,
ServerProviderModel,
ProviderInstanceId,
type ServerConfig,
} from "@akeru/contracts";
import {
buildModelOptions,
groupByProvider,
resolveDefaultableModelSelection,
resolveModelSendBlock,
resolveSelectableModelSelection,
} from "./modelOptions";
type ProviderFixture = Omit<Partial<typeof ServerProvider.Encoded>, "models"> & {
readonly models?: ReadonlyArray<
Partial<typeof ServerProviderModel.Encoded> & { readonly slug: string; readonly name: string }
>;
};
const decodeProviderFixture = Schema.decodeUnknownSync(ServerProvider);
function serverConfig(providers: ReadonlyArray<ProviderFixture>): ServerConfig {
return makeMobileServerConfig({
providers: providers.map((provider) =>
decodeProviderFixture({
enabled: true,
installed: true,
version: null,
status: "ready",
auth: { status: "authenticated" },
checkedAt: "2026-01-01T00:00:00Z",
slashCommands: [],
skills: [],
...provider,
models: (provider.models ?? []).map((model) => ({
isCustom: false,
capabilities: null,
...model,
})),
}),
),
});
}
describe("mobile model options", () => {
it("groups models by provider and flags legacy entries", () => {
const config = serverConfig([
{
instanceId: "codex",
driver: "codex",
displayName: "Codex",
enabled: true,
installed: true,
auth: { status: "authenticated" },
models: [
{
slug: "gpt-5.6-sol",
name: "GPT-5.6 Sol",
isCustom: false,
capabilities: null,
},
{
slug: "gpt-5.4",
name: "GPT-5.4",
isCustom: false,
isLegacy: true,
capabilities: null,
},
],
},
]);
expect(groupByProvider(buildModelOptions(config, null))).toMatchObject([
{
providerKey: "codex",
providerLabel: "Codex",
models: [
{ key: "codex:gpt-5.6-sol", label: "GPT-5.6 Sol", isLegacy: false },
{ key: "codex:gpt-5.4", label: "GPT-5.4", isLegacy: true },
],
},
]);
});
it("lists host-detected models for disconnected subscriptions as disabled", () => {
const config = serverConfig([
{
instanceId: "codex",
driver: "codex",
enabled: true,
installed: true,
auth: { status: "authenticated" },
models: [{ slug: "gpt-5.6-sol", name: "GPT-5.6 Sol", capabilities: null }],
},
{
instanceId: "grok",
driver: "grok",
enabled: true,
installed: true,
auth: { status: "unknown" },
models: [{ slug: "grok-build", name: "Grok Build", capabilities: null }],
},
]);
const options = buildModelOptions(config, null, [
{
provider: "openai-codex",
connected: false,
health: "missing",
dependentBots: [],
dependentRoutines: [],
},
{
provider: "xai",
connected: true,
health: "detected",
dependentBots: [],
dependentRoutines: [],
},
]);
expect(
options.map((option) => [option.key, option.disabledReason?.split(".")[0] ?? null]),
).toEqual([
["codex:gpt-5.6-sol", "Codex is not connected"],
["grok:grok-build", null],
]);
});
it("keeps unavailable providers' models visible with their reason", () => {
const config = serverConfig([
{
instanceId: "claudeAgent",
driver: "claudeAgent",
enabled: true,
installed: true,
auth: { status: "unauthenticated" },
unavailability: "missing-login",
models: [{ slug: "claude-opus", name: "Claude Opus", capabilities: null }],
},
{
instanceId: "kimi",
driver: "kimi",
enabled: false,
installed: true,
auth: { status: "authenticated" },
models: [{ slug: "kimi-k3", name: "Kimi K3", capabilities: null }],
},
{
instanceId: "grok",
driver: "grok",
enabled: true,
installed: true,
auth: { status: "authenticated" },
unavailability: "temporary-failure",
models: [{ slug: "grok-build", name: "Grok Build", capabilities: null }],
},
]);
const options = buildModelOptions(config, null);
expect(options.map((option) => [option.key, option.disabledReason])).toEqual([
[
"claudeAgent:claude-opus",
"Claude is not connected. Connect your Claude account in Settings > Providers.",
],
[
"kimi:kimi-k3",
"Kimi For Coding is turned off. Turn Kimi For Coding on in Settings > Providers, then send your message again.",
],
["grok:grok-build", null],
]);
});
it("keeps a saved selection visible after its provider drops the model", () => {
const config = serverConfig([
{
instanceId: "codex",
driver: "codex",
enabled: true,
installed: true,
auth: { status: "authenticated" },
models: [{ slug: "gpt-5.6-sol", name: "GPT-5.6 Sol", capabilities: null }],
},
]);
const saved = buildModelOptions(config, {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-4-retired",
}).find((option) => option.key === "codex:gpt-4-retired");
expect(saved?.providerLabel).toBe("Codex");
expect(saved?.disabledReason).toBe(
"gpt-4-retired is not available on Codex. Pick another model for this bot.",
);
});
it("normalizes a legacy fallback selection against current capabilities", () => {
const config = serverConfig([
{
instanceId: "codex",
driver: "codex",
displayName: "Codex",
enabled: true,
installed: true,
auth: { status: "authenticated" },
models: [
{
slug: "gpt-test",
name: "GPT Test",
isCustom: false,
capabilities: {
optionDescriptors: [
{
id: "serviceTier",
label: "Service Tier",
type: "select",
options: [
{ id: "default", label: "Standard", isDefault: true },
{ id: "priority", label: "Fast" },
],
currentValue: "default",
},
],
},
},
],
},
]);
const [option] = buildModelOptions(config, {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-test",
options: [{ id: "fastMode", value: true }],
});
expect(option?.capabilities?.optionDescriptors?.[0]?.id).toBe("serviceTier");
expect(option?.selection.options).toEqual([{ id: "serviceTier", value: "default" }]);
});
it("rejects stored selections whose provider is not usable", () => {
const config = serverConfig([
{
instanceId: "codex",
driver: "codex",
enabled: true,
installed: true,
auth: { status: "authenticated" },
models: [],
},
{
instanceId: "claudeAgent",
driver: "claudeAgent",
enabled: false,
installed: true,
auth: { status: "authenticated" },
models: [],
},
]);
const usable = {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.6-sol",
};
const disabled = {
instanceId: ProviderInstanceId.make("claudeAgent"),
model: "claude-sonnet-5",
};
const removed = {
instanceId: ProviderInstanceId.make("codex_personal"),
model: "gpt-5.6-sol",
};
expect(resolveSelectableModelSelection(config, usable)).toBe(usable);
expect(resolveSelectableModelSelection(config, disabled)).toBeNull();
expect(resolveSelectableModelSelection(config, removed)).toBeNull();
// No config (environment offline) — nothing to validate against.
expect(resolveSelectableModelSelection(null, disabled)).toBe(disabled);
});
it("keeps legacy models out of implicit defaults", () => {
const config = serverConfig([
{
instanceId: "codex",
driver: "codex",
displayName: "Codex",
enabled: true,
installed: true,
auth: { status: "authenticated" },
models: [
{ slug: "gpt-5.6-sol", name: "GPT-5.6 Sol", isCustom: false, capabilities: null },
{
slug: "gpt-5.4",
name: "GPT-5.4",
isCustom: false,
isLegacy: true,
capabilities: null,
},
],
},
]);
const current = { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.6-sol" };
const legacy = { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" };
expect(resolveDefaultableModelSelection(config, current)).toBe(current);
// A legacy last-used selection falls through to the provider default.
expect(resolveDefaultableModelSelection(config, legacy)).toBeNull();
// Offline: nothing to validate against, selection passes through.
expect(resolveDefaultableModelSelection(null, legacy)).toBe(legacy);
});
});
describe("resolveModelSendBlock", () => {
const claude = (patch: ProviderFixture) =>
serverConfig([
{
instanceId: "claudeAgent",
driver: "claudeAgent",
enabled: true,
installed: true,
auth: { status: "authenticated" },
models: [{ slug: "claude-opus", name: "Claude Opus", isCustom: false }],
...patch,
},
]);
const selection = { instanceId: ProviderInstanceId.make("claudeAgent"), model: "claude-opus" };
it("blocks Send with the provider, what failed, and the next step", () => {
const block = resolveModelSendBlock(
claude({ auth: { status: "unauthenticated" }, unavailability: "missing-login" }),
selection,
);
expect(block).toMatchObject({ title: "Claude is not connected", action: "providers" });
});
it("explains the block in the active interface language", async () => {
const zh = createTranslator("zh-CN", await catalogRegistry["zh-CN"]!());
const block = resolveModelSendBlock(
claude({ auth: { status: "unauthenticated" }, unavailability: "missing-login" }),
selection,
zh.t,
);
expect(block).toMatchObject({ title: "Claude 未连接", action: "providers" });
});
it("names the saved model when the provider no longer offers it", () => {
const block = resolveModelSendBlock(claude({ models: [{ slug: "other", name: "Other" }] }), {
...selection,
});
expect(block?.title).toBe("claude-opus is not available on Claude");
});
it("lets a temporary failure or an offline environment through", () => {
expect(resolveModelSendBlock(claude({ unavailability: "temporary-failure" }), selection)).toBe(
null,
);
expect(resolveModelSendBlock(null, selection)).toBe(null);
expect(resolveModelSendBlock(claude({}), selection)).toBe(null);
});
it("blocks a disconnected built-in subscription but keeps a custom instance usable", () => {
const disconnected = [
{
provider: "anthropic" as const,
connected: false,
dependentBots: [],
dependentRoutines: [],
},
];
expect(resolveModelSendBlock(claude({}), selection, undefined, disconnected)?.title).toBe(
"Claude is not connected",
);
const customSelection = { ...selection, instanceId: ProviderInstanceId.make("claude_work") };
const custom = claude({ instanceId: customSelection.instanceId });
expect(resolveModelSendBlock(custom, customSelection, undefined, disconnected)).toBeNull();
});
});