sailfork / t3code-github / apps/ web/ src/ providerInstances.test.ts

import {
  DEFAULT_MODEL_BY_PROVIDER,
  ProjectId,
  ProviderDriverKind,
  ProviderInstanceId,
  type ServerProvider,
} from "@t3tools/contracts";
import { describe, expect, it } from "vite-plus/test";
import {
  applyProviderInstanceSettings,
  brandProviderInstanceEntries,
  deriveProviderEntriesByEnvironment,
  deriveProviderInstanceEntries,
  getDefaultProviderInstanceModel,
  isProviderInstancePickerReady,
  resolveDefaultProviderModelSelection,
  resolveSelectableProviderInstance,
  shouldShowInstanceBadge,
} from "./providerInstances";

function provider(input: {
  provider: ProviderDriverKind;
  instanceId: string;
  enabled?: boolean;
  availability?: ServerProvider["availability"];
  displayName?: string;
  accentColor?: string;
  status?: ServerProvider["status"];
  models?: ServerProvider["models"];
  supportsTextGeneration?: boolean;
}): ServerProvider {
  return {
    instanceId: ProviderInstanceId.make(input.instanceId),
    driver: input.provider,
    ...(input.supportsTextGeneration === undefined
      ? {}
      : { supportsTextGeneration: input.supportsTextGeneration }),
    ...(input.displayName ? { displayName: input.displayName } : {}),
    ...(input.accentColor ? { accentColor: input.accentColor } : {}),
    enabled: input.enabled ?? true,
    installed: true,
    version: null,
    status: input.status ?? "ready",
    ...(input.availability ? { availability: input.availability } : {}),
    auth: { status: "authenticated" },
    checkedAt: "2026-01-01T00:00:00.000Z",
    models: input.models ?? [],
    slashCommands: [],
    skills: [],
  };
}

const model = (slug: string, isCustom = false, isDefault = false) => ({
  slug,
  name: slug,
  isCustom,
  ...(isDefault ? { isDefault: true } : {}),
  capabilities: {},
});

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);
  });
});

describe("applyProviderInstanceSettings", () => {
  it("uses settings when a streamed snapshot still reports a disabled default as enabled", () => {
    const entries = deriveProviderInstanceEntries([
      provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),
    ]);
    const [entry] = applyProviderInstanceSettings(
      entries,
      {
        providerInstances: {
          [ProviderInstanceId.make("codex")]: {
            driver: ProviderDriverKind.make("codex"),
            enabled: false,
          },
        },
        projectSettingsOverrides: {},
      },
      null,
    );

    expect(entry?.enabled).toBe(false);
  });

  it.each(["constructor", "toString"])(
    "treats a removed custom instance named %s as disabled",
    (instanceId) => {
      const entries = deriveProviderInstanceEntries([
        provider({
          provider: ProviderDriverKind.make("claudeAgent"),
          instanceId,
        }),
      ]);
      const [entry] = applyProviderInstanceSettings(
        entries,
        {
          providerInstances: {},
          projectSettingsOverrides: {},
        },
        null,
      );

      expect(entry?.enabled).toBe(false);
    },
  );

  // regression: #8337 provider ids matching Object.prototype keys resolved to prototype members
  it("uses settings for a configured custom instance named constructor", () => {
    const instanceId = ProviderInstanceId.make("constructor");
    const entries = deriveProviderInstanceEntries([
      provider({
        provider: ProviderDriverKind.make("claudeAgent"),
        instanceId,
      }),
    ]);
    const [entry] = applyProviderInstanceSettings(
      entries,
      {
        providerInstances: {
          [instanceId]: {
            driver: ProviderDriverKind.make("claudeAgent"),
            enabled: false,
          },
        },
        projectSettingsOverrides: {},
      },
      null,
    );

    expect(entry?.enabled).toBe(false);
  });

  it("uses the driver default for an unconfigured built-in default instance", () => {
    const entries = deriveProviderInstanceEntries([
      provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex", enabled: false }),
      provider({ provider: ProviderDriverKind.make("grok"), instanceId: "grok", enabled: true }),
    ]);
    const [codex, grok] = applyProviderInstanceSettings(
      entries,
      {
        providerInstances: {},
        projectSettingsOverrides: {},
      },
      null,
    );

    expect(codex?.enabled).toBe(true);
    expect(grok?.enabled).toBe(false);
  });
});

describe("deriveProviderEntriesByEnvironment", () => {
  it("resolves registry branding from each environment's settings", () => {
    const instanceId = "custom-acp";
    const snapshot = provider({ provider: ProviderDriverKind.make("acpRegistry"), instanceId });
    const byEnvironment = deriveProviderEntriesByEnvironment(
      ["devin", "other-agent"].map(
        (agentId) =>
          [
            agentId,
            [snapshot],
            {
              providerInstances: {
                [instanceId]: {
                  driver: ProviderDriverKind.make("acpRegistry"),
                  enabled: true,
                  config: { agentId, registryIconUrl: `https://example.com/${agentId}.svg` },
                },
              },
              projectSettingsOverrides: {},
            },
          ] as const,
      ),
    );
    expect(byEnvironment.get("devin")?.get(instanceId)?.acpRegistryAgentId).toBe("devin");
    expect(byEnvironment.get("devin")?.get(instanceId)?.acpRegistryIconUrl).toBe(
      "https://example.com/devin.svg",
    );
    expect(byEnvironment.get("other-agent")?.get(instanceId)?.acpRegistryAgentId).toBe(
      "other-agent",
    );
  });

  // regression: #7292 sidebar provider icons resolved from the wrong environment
  it("keeps same-id default instances distinct per environment", () => {
    const byEnvironment = deriveProviderEntriesByEnvironment([
      [
        "local",
        [
          provider({
            provider: ProviderDriverKind.make("claude"),
            instanceId: "claude",
            displayName: "Claude Local",
            accentColor: "#112233",
          }),
        ],
      ],
      [
        "remote",
        [
          provider({
            provider: ProviderDriverKind.make("claude"),
            instanceId: "claude",
            displayName: "Claude Remote",
            accentColor: "#445566",
          }),
        ],
      ],
    ]);

    expect(byEnvironment.get("local")?.get("claude")?.displayName).toBe("Claude Local");
    expect(byEnvironment.get("local")?.get("claude")?.accentColor).toBe("#112233");
    expect(byEnvironment.get("remote")?.get("claude")?.displayName).toBe("Claude Remote");
    expect(byEnvironment.get("remote")?.get("claude")?.accentColor).toBe("#445566");
  });

  it("keeps an instance a project turns on as a sibling for the instance badge", () => {
    const codex = ProviderDriverKind.make("codex");
    const byEnvironment = deriveProviderEntriesByEnvironment([
      [
        "local",
        [
          provider({ provider: codex, instanceId: "codex" }),
          provider({ provider: codex, instanceId: "codex_work" }),
        ],
        {
          providerInstances: {
            [ProviderInstanceId.make("codex_work")]: { driver: codex, enabled: false },
          },
          projectSettingsOverrides: {
            [ProjectId.make("project-work")]: {
              providerInstances: { [ProviderInstanceId.make("codex_work")]: { enabled: true } },
            },
          },
        },
      ],
    ]);
    const entries = byEnvironment.get("local");
    const personal = entries?.get("codex");

    expect(personal && shouldShowInstanceBadge(personal, entries?.values() ?? [])).toBe(true);
  });
});

describe("brandProviderInstanceEntries", () => {
  it("keeps an instance a project turns on as a sibling for the instance badge", () => {
    const codex = ProviderDriverKind.make("codex");
    const settings = {
      providerInstances: {
        [ProviderInstanceId.make("codex_work")]: { driver: codex, enabled: false },
      },
      projectSettingsOverrides: {
        [ProjectId.make("project-work")]: {
          providerInstances: { [ProviderInstanceId.make("codex_work")]: { enabled: true } },
        },
      },
    };
    const entries = brandProviderInstanceEntries(
      deriveProviderInstanceEntries([
        provider({ provider: codex, instanceId: "codex" }),
        provider({ provider: codex, instanceId: "codex_work" }),
      ]),
      settings,
    );
    const personal = entries.find((entry) => entry.instanceId === "codex");

    expect(personal && shouldShowInstanceBadge(personal, entries)).toBe(true);
  });
});

describe("resolveSelectableProviderInstance", () => {
  it("falls back to the first enabled and available instance", () => {
    const disabled = ProviderInstanceId.make("codex");
    const fallback = ProviderInstanceId.make("claudeAgent");
    const providers = [
      provider({
        provider: ProviderDriverKind.make("codex"),
        instanceId: disabled,
        enabled: false,
      }),
      provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: fallback }),
    ];

    expect(resolveSelectableProviderInstance(providers, disabled)).toBe(fallback);
  });

  it("prefers a ready instance over an enabled one whose driver cannot start", () => {
    const notInstalled = ProviderInstanceId.make("codex");
    const ready = ProviderInstanceId.make("claudeAgent");
    const providers = [
      provider({
        provider: ProviderDriverKind.make("codex"),
        instanceId: notInstalled,
        status: "error",
      }),
      provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: ready }),
    ];

    expect(resolveSelectableProviderInstance(providers, undefined)).toBe(ready);
  });

  it("keeps a requested instance even when its probe errored", () => {
    const requested = ProviderInstanceId.make("codex");
    const providers = [
      provider({
        provider: ProviderDriverKind.make("codex"),
        instanceId: requested,
        status: "error",
      }),
      provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: "claudeAgent" }),
    ];

    expect(resolveSelectableProviderInstance(providers, requested)).toBe(requested);
  });

  // regression: #4117 users without Codex got a broken default provider
  it("does not invent an errored instance as a new-user default", () => {
    const notInstalled = ProviderInstanceId.make("codex");
    const providers = [
      provider({
        provider: ProviderDriverKind.make("codex"),
        instanceId: notInstalled,
        status: "error",
      }),
    ];

    expect(resolveSelectableProviderInstance(providers, undefined)).toBeUndefined();
  });

  it("does not return disabled, unavailable, or unknown instances when none are sendable", () => {
    const disabled = ProviderInstanceId.make("codex");
    const unavailable = ProviderInstanceId.make("claudeAgent");
    const unknown = ProviderInstanceId.make("removed_instance");
    const providers = [
      provider({
        provider: ProviderDriverKind.make("codex"),
        instanceId: disabled,
        enabled: false,
      }),
      provider({
        provider: ProviderDriverKind.make("claudeAgent"),
        instanceId: unavailable,
        availability: "unavailable",
      }),
    ];

    expect(resolveSelectableProviderInstance(providers, disabled)).toBeUndefined();
    expect(resolveSelectableProviderInstance(providers, unavailable)).toBeUndefined();
    expect(resolveSelectableProviderInstance(providers, unknown)).toBeUndefined();
  });
});

describe("getDefaultProviderInstanceModel", () => {
  it("uses the instance's own models, not the default instance of the kind", () => {
    const providers = [
      provider({
        provider: ProviderDriverKind.make("claudeAgent"),
        instanceId: "claude_openrouter",
        models: [model("openai/gpt-5.5", true), model("claude-opus-4-8")],
      }),
      provider({
        provider: ProviderDriverKind.make("claudeAgent"),
        instanceId: "claudeAgent",
        models: [model("claude-sonnet-5")],
      }),
    ];

    expect(
      getDefaultProviderInstanceModel(providers, ProviderInstanceId.make("claude_openrouter")),
    ).toBe("claude-opus-4-8");
  });

  it("falls back to the driver default when the instance reports no models", () => {
    const providers = [
      provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: "claudeAgent" }),
    ];

    const resolved = getDefaultProviderInstanceModel(
      providers,
      ProviderInstanceId.make("claudeAgent"),
    );
    expect(resolved).toBe(DEFAULT_MODEL_BY_PROVIDER[ProviderDriverKind.make("claudeAgent")]);
  });

  it("honors the instance's declared default before model-list order", () => {
    const providers = [
      provider({
        provider: ProviderDriverKind.make("claudeAgent"),
        instanceId: "claudeAgent",
        models: [model("claude-sonnet-5"), model("claude-opus-4-8", false, true)],
      }),
    ];

    expect(getDefaultProviderInstanceModel(providers, ProviderInstanceId.make("claudeAgent"))).toBe(
      "claude-opus-4-8",
    );
  });
});

describe("resolveDefaultProviderModelSelection", () => {
  // regression: #4117 users without Codex got a broken default provider
  it.each([
    ["codex", "codex", "gpt-5.6"],
    ["claudeAgent", "claudeAgent", "claude-fable-5"],
    ["cursor", "cursor", "composer-2"],
  ])("uses the only available %s instance", (driver, instanceId, modelSlug) => {
    const providers = [
      provider({
        provider: ProviderDriverKind.make(driver),
        instanceId,
        models: [model(modelSlug, false, true)],
      }),
    ];

    expect(resolveDefaultProviderModelSelection(providers, null)).toEqual({
      instanceId,
      model: modelSlug,
    });
  });

  it("preserves a valid stored selection including its options", () => {
    const providers = [
      provider({
        provider: ProviderDriverKind.make("claudeAgent"),
        instanceId: "claudeAgent",
        models: [model("claude-opus-4-8")],
      }),
    ];
    const stored = {
      instanceId: ProviderInstanceId.make("claudeAgent"),
      model: "custom-model",
      options: [{ id: "effort", value: "high" }],
    };

    expect(resolveDefaultProviderModelSelection(providers, stored)).toBe(stored);
  });

  it("replaces a stale stored instance with the first ready instance and its model", () => {
    const providers = [
      provider({
        provider: ProviderDriverKind.make("codex"),
        instanceId: "codex",
        status: "warning",
        models: [model("gpt-5.6")],
      }),
      provider({
        provider: ProviderDriverKind.make("claudeAgent"),
        instanceId: "claudeAgent",
        models: [model("claude-opus-4-8", false, true)],
      }),
    ];

    expect(
      resolveDefaultProviderModelSelection(providers, {
        instanceId: ProviderInstanceId.make("removed-provider"),
        model: "stale-model",
      }),
    ).toEqual({ instanceId: "claudeAgent", model: "claude-opus-4-8" });
  });

  // regression: #4117 users without Codex got a broken default provider
  it.each([{ enabled: false }, { availability: "unavailable" as const }])(
    "replaces an unavailable stored instance deterministically",
    (requestedState) => {
      const providers = [
        provider({
          provider: ProviderDriverKind.make("codex"),
          instanceId: "codex",
          models: [model("gpt-5.6")],
          ...requestedState,
        }),
        provider({
          provider: ProviderDriverKind.make("claudeAgent"),
          instanceId: "claudeAgent",
          models: [model("claude-opus-4-8", false, true)],
        }),
      ];

      expect(
        resolveDefaultProviderModelSelection(providers, {
          instanceId: ProviderInstanceId.make("codex"),
          model: "gpt-5.6",
        }),
      ).toEqual({ instanceId: "claudeAgent", model: "claude-opus-4-8" });
    },
  );

  it("returns no selection for empty, disabled, unavailable, or error-only profiles", () => {
    expect(resolveDefaultProviderModelSelection([], null)).toBeNull();
    expect(
      resolveDefaultProviderModelSelection(
        [
          provider({
            provider: ProviderDriverKind.make("codex"),
            instanceId: "codex",
            enabled: false,
          }),
        ],
        null,
      ),
    ).toBeNull();
    expect(
      resolveDefaultProviderModelSelection(
        [
          provider({
            provider: ProviderDriverKind.make("codex"),
            instanceId: "codex",
            availability: "unavailable",
          }),
        ],
        null,
      ),
    ).toBeNull();
    expect(
      resolveDefaultProviderModelSelection(
        [
          provider({
            provider: ProviderDriverKind.make("codex"),
            instanceId: "codex",
            status: "error",
          }),
        ],
        null,
      ),
    ).toBeNull();
  });
});

describe("provider icon metadata", () => {
  it("clears stale registry branding when an instance switches to a local command", () => {
    const instanceId = ProviderInstanceId.make("custom-acp");
    const driver = ProviderDriverKind.make("acpRegistry");
    const iconUrl = "https://cdn.agentclientprotocol.com/registry/icons/swe-agent.svg";
    const snapshots = deriveProviderInstanceEntries([
      { ...provider({ provider: driver, instanceId }), iconUrl },
    ]);
    const registryConfig = { agentId: "swe-agent", registryIconUrl: iconUrl };
    const brandedEntries = applyProviderInstanceSettings(
      snapshots,
      {
        providerInstances: { [instanceId]: { driver, enabled: true, config: registryConfig } },
        projectSettingsOverrides: {},
      },
      null,
    );
    expect(brandedEntries[0]?.acpRegistryAgentId).toBe("swe-agent");
    expect(brandedEntries[0]?.acpRegistryIconUrl).toBe(iconUrl);

    const [localEntry] = applyProviderInstanceSettings(
      brandedEntries,
      {
        providerInstances: {
          [instanceId]: {
            driver,
            enabled: false,
            config: { ...registryConfig, source: "local", commandPath: "dsh" },
          },
        },
        projectSettingsOverrides: {},
      },
      null,
    );
    expect(localEntry?.acpRegistryAgentId).toBeUndefined();
    expect(localEntry?.acpRegistryIconUrl).toBeUndefined();
    expect(localEntry?.enabled).toBe(false);
    expect(localEntry?.snapshot).toBe(snapshots[0]?.snapshot);

    const [restoredEntry] = applyProviderInstanceSettings(
      localEntry ? [localEntry] : [],
      {
        providerInstances: { [instanceId]: { driver, enabled: true, config: registryConfig } },
        projectSettingsOverrides: {},
      },
      null,
    );
    expect(restoredEntry?.acpRegistryAgentId).toBe("swe-agent");
    expect(restoredEntry?.acpRegistryIconUrl).toBe(iconUrl);
    expect(restoredEntry?.enabled).toBe(true);
  });
});