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.

6.5 KB
Raw Blame
import { ProviderDriverKind } from "@akeru/contracts";
import { describe, expect, it } from "vite-plus/test";
import {
  deriveProviderInstanceEntries,
  isProviderInstancePickerReady,
  isProviderInstancePickerSelectable,
  isProviderInstancePickerVisible,
  providerInstancePickerBlockReason,
  providerInstanceUnavailableReason,
} from "./providerInstances";
import { provider, model } from "./providerInstances.test-support";

describe("isProviderInstancePickerReady", () => {
  it("rejects a disabled instance even while its last probe status is ready", () => {
    const [entry] = deriveProviderInstanceEntries([
      provider({
        provider: ProviderDriverKind.make("codex"),
        instanceId: "codex",
        enabled: false,
      }),
    ]);

    expect(entry?.status).toBe("ready");
    expect(entry && isProviderInstancePickerReady(entry)).toBe(false);
  });

  it("accepts an enabled, available, ready instance", () => {
    const [entry] = deriveProviderInstanceEntries([
      provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),
    ]);

    expect(entry && isProviderInstancePickerReady(entry)).toBe(true);
  });
});

describe("isProviderInstancePickerSelectable", () => {
  it("keeps installed provider models selectable while the probe is limited", () => {
    const [entry] = deriveProviderInstanceEntries([
      provider({
        provider: ProviderDriverKind.make("grok"),
        instanceId: "grok",
        status: "warning",
        models: [model("grok-build")],
      }),
    ]);

    expect(entry && isProviderInstancePickerSelectable(entry)).toBe(true);
  });

  it("rejects missing and explicitly unauthenticated providers", () => {
    const [missing, unauthenticated] = deriveProviderInstanceEntries([
      provider({
        provider: ProviderDriverKind.make("grok"),
        instanceId: "grok_missing",
        installed: false,
      }),
      provider({
        provider: ProviderDriverKind.make("grok"),
        instanceId: "grok_signed_out",
        authStatus: "unauthenticated",
      }),
    ]);

    expect(missing && isProviderInstancePickerSelectable(missing)).toBe(false);
    expect(unauthenticated && isProviderInstancePickerSelectable(unauthenticated)).toBe(false);
  });

  it("rejects disabled provider snapshots with explicit or omitted availability", () => {
    const [available, availabilityOmitted] = deriveProviderInstanceEntries([
      provider({
        provider: ProviderDriverKind.make("grok"),
        instanceId: "grok_available",
        status: "disabled",
        availability: "available",
      }),
      provider({
        provider: ProviderDriverKind.make("grok"),
        instanceId: "grok_availability_omitted",
        status: "disabled",
      }),
    ]);

    expect(available && isProviderInstancePickerSelectable(available)).toBe(false);
    expect(availabilityOmitted && isProviderInstancePickerSelectable(availabilityOmitted)).toBe(
      false,
    );
  });
});

describe("isProviderInstancePickerVisible", () => {
  it("shows disabled instances with known models so their reason remains visible", () => {
    const [enabledEntry, disabledEntry, missingEntry, signedOutEntry] =
      deriveProviderInstanceEntries([
        provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),
        provider({
          provider: ProviderDriverKind.make("claudeAgent"),
          instanceId: "claudeAgent",
          enabled: false,
          models: [model("sonnet")],
        }),
        provider({
          provider: ProviderDriverKind.make("kimi"),
          instanceId: "kimi",
          installed: false,
        }),
        provider({
          provider: ProviderDriverKind.make("opencodeGo"),
          instanceId: "opencodeGo",
          authStatus: "unauthenticated",
        }),
      ]);

    expect(enabledEntry && isProviderInstancePickerVisible(enabledEntry)).toBe(true);
    expect(disabledEntry && isProviderInstancePickerVisible(disabledEntry)).toBe(true);
    expect(disabledEntry && isProviderInstancePickerSelectable(disabledEntry)).toBe(false);
    expect(disabledEntry && providerInstancePickerBlockReason(disabledEntry)).toContain(
      "turned off",
    );
    expect(missingEntry && isProviderInstancePickerVisible(missingEntry)).toBe(true);
    expect(signedOutEntry && isProviderInstancePickerVisible(signedOutEntry)).toBe(true);
    expect(signedOutEntry && isProviderInstancePickerSelectable(signedOutEntry)).toBe(false);
  });
});

describe("providerInstanceUnavailableReason", () => {
  it("names the provider and the next action for each blocking state", () => {
    const [ready, signedOut, missing, limited, flaky] = deriveProviderInstanceEntries([
      provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),
      provider({
        provider: ProviderDriverKind.make("claudeAgent"),
        instanceId: "claudeAgent",
        authStatus: "unauthenticated",
      }),
      provider({
        provider: ProviderDriverKind.make("kimi"),
        instanceId: "kimi",
        installed: false,
      }),
      {
        ...provider({ provider: ProviderDriverKind.make("grok"), instanceId: "grok" }),
        unavailability: "limit-reached",
      },
      {
        ...provider({ provider: ProviderDriverKind.make("opencodeGo"), instanceId: "opencodeGo" }),
        unavailability: "temporary-failure",
      },
    ]);

    expect(providerInstanceUnavailableReason(ready)).toBeNull();
    expect(providerInstanceUnavailableReason(signedOut)).toMatch(
      /not connected.*Settings > Providers/,
    );
    expect(providerInstanceUnavailableReason(missing)).toMatch(/not installed/);
    expect(providerInstanceUnavailableReason(limited)).toMatch(/limit reached/);
    expect(providerInstanceUnavailableReason(undefined, { providerName: "Codex" })).toMatch(
      /Codex is not set up/,
    );

    expect(limited && providerInstancePickerBlockReason(limited)).toMatch(/limit reached/);
    expect(flaky && providerInstancePickerBlockReason(flaky)).toBeNull();
    expect(flaky && isProviderInstancePickerSelectable(flaky)).toBe(true);
  });

  it("flags a saved model the provider no longer offers", () => {
    const [entry] = deriveProviderInstanceEntries([
      provider({
        provider: ProviderDriverKind.make("codex"),
        instanceId: "codex",
        models: [model("gpt-5.5")],
      }),
    ]);

    expect(providerInstanceUnavailableReason(entry, { model: "gpt-5.5" })).toBeNull();
    expect(providerInstanceUnavailableReason(entry, { model: "retired-model" })).toMatch(
      /retired-model is not available on/,
    );
  });
});