Skip to content

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.

11.8 KB
Raw Blame
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();
  });
});