import { ProviderDriverKind, ProviderInstanceId, type ServerProvider } from "@t3tools/contracts";import { describe, expect, it } from "vite-plus/test";import {  applyProviderInstanceSettings,  deriveProviderInstanceEntries,  isProviderInstancePickerReady,  isProviderInstancePickerVisible,  resolveSelectableProviderInstance,  resolveProviderDriverKindForInstanceSelection,} from "./providerInstances"; function provider(input: {  provider: ProviderDriverKind;  instanceId: string;  enabled?: boolean;  availability?: ServerProvider["availability"];  displayName?: string;}): ServerProvider {  return {    instanceId: ProviderInstanceId.make(input.instanceId),    driver: input.provider,    ...(input.displayName ? { displayName: input.displayName } : {}),    enabled: input.enabled ?? true,    installed: true,    version: null,    status: "ready",    ...(input.availability ? { availability: input.availability } : {}),    auth: { status: "authenticated" },    checkedAt: "2026-01-01T00:00:00.000Z",    models: [],    slashCommands: [],    skills: [],  };} 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("isProviderInstancePickerVisible", () => {  it("keeps enabled instances in the rail and removes disabled instances", () => {    const [enabledEntry, disabledEntry] = deriveProviderInstanceEntries([      provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),      provider({        provider: ProviderDriverKind.make("claudeAgent"),        instanceId: "claudeAgent",        enabled: false,      }),    ]);     expect(enabledEntry && isProviderInstancePickerVisible(enabledEntry)).toBe(true);    expect(disabledEntry && isProviderInstancePickerVisible(disabledEntry)).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,        },      },      providers: {} as never,    });     expect(entry?.enabled).toBe(false);  });   it("treats a removed custom instance snapshot as disabled", () => {    const entries = deriveProviderInstanceEntries([      provider({        provider: ProviderDriverKind.make("claudeAgent"),        instanceId: "claude_work",      }),    ]);    const [entry] = applyProviderInstanceSettings(entries, {      providerInstances: {},      providers: {} as never,    });     expect(entry?.enabled).toBe(false);  });}); describe("deriveProviderInstanceEntries", () => {  it("uses explicit instance id and driver kind from the snapshot", () => {    const snapshot = provider({      provider: ProviderDriverKind.make("codex"),      instanceId: "codex_personal",    });    const [entry] = deriveProviderInstanceEntries([snapshot]);     expect(entry?.instanceId).toBe("codex_personal");    expect(entry?.driverKind).toBe("codex");    expect(entry?.isDefault).toBe(false);  });}); describe("resolveSelectableProviderInstance", () => {  it("returns the requested instance when it is enabled and available", () => {    const requested = ProviderInstanceId.make("claude_work");    const providers = [      provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),      provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: requested }),    ];     expect(resolveSelectableProviderInstance(providers, requested)).toBe(requested);  });   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("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("resolveProviderDriverKindForInstanceSelection", () => {  it("maps custom provider instance ids back to their driver kind", () => {    const providers = [      provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),      provider({        provider: ProviderDriverKind.make("claudeAgent"),        instanceId: "claude_openrouter",        displayName: "Claude OpenRouter",      }),    ];    const entries = deriveProviderInstanceEntries(providers);     expect(      resolveProviderDriverKindForInstanceSelection(        entries,        providers,        ProviderInstanceId.make("claude_openrouter"),      ),    ).toBe("claudeAgent");  });   it("does not guess a provider kind when the instance selection is unknown", () => {    const providers = [      provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex", enabled: false }),      provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: "claudeAgent" }),    ];    const entries = deriveProviderInstanceEntries(providers);     expect(      resolveProviderDriverKindForInstanceSelection(        entries,        providers,        ProviderInstanceId.make("removed_instance"),      ),    ).toBeUndefined();  });});