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 * as Predicate from "effect/Predicate";
import { ProviderDriverKind, ProviderInstanceId } from "@akeru/contracts";
import { describe, expect, it } from "vite-plus/test";
import {
deriveProviderInstanceEntries,
getDefaultProviderInstanceModel,
resolveDefaultProviderModelSelection,
resolveSelectableProviderInstance,
resolveProviderDriverKindForInstanceSelection,
} from "./providerInstances";
import { provider, model } from "./providerInstances.test-support";
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("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("prefers an unprobed (warning) instance over one whose probe errored", () => {
const notInstalled = ProviderInstanceId.make("codex");
const unprobed = ProviderInstanceId.make("claudeAgent");
const providers = [
provider({
provider: ProviderDriverKind.make("codex"),
instanceId: notInstalled,
status: "error",
}),
provider({
provider: ProviderDriverKind.make("claudeAgent"),
instanceId: unprobed,
status: "warning",
}),
];
expect(resolveSelectableProviderInstance(providers, undefined)).toBe(unprobed);
});
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);
});
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("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();
});
});
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(Predicate.isString(resolved)).toBe(true);
expect(resolved?.length).toBeGreaterThan(0);
});
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",
);
});
it("returns undefined for an unknown instance", () => {
expect(
getDefaultProviderInstanceModel([], ProviderInstanceId.make("removed_instance")),
).toBeUndefined();
});
});
describe("resolveDefaultProviderModelSelection", () => {
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" });
});
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();
});
});