import { describe, expect, it } from "vite-plus/test";
import { ProviderInstanceId, type ModelCapabilities } from "@t3tools/contracts";
import {
applyClaudePromptEffortPrefix,
buildExplicitProviderOptionSelectionsFromDescriptors,
buildProviderOptionSelectionsFromDescriptors,
createModelCapabilities,
createModelSelection,
getProviderOptionCurrentLabel,
getProviderOptionDescriptors,
readCustomModelEntries,
modelSelectionsEqual,
} from "./model.ts";
const codexCaps: ModelCapabilities = createModelCapabilities({
optionDescriptors: [
{
id: "reasoningEffort",
label: "Reasoning",
type: "select",
options: [
{ id: "xhigh", label: "Extra High" },
{ id: "high", label: "High", isDefault: true },
],
currentValue: "high",
},
{
id: "fastMode",
label: "Fast Mode",
type: "boolean",
},
],
});
describe("descriptor helpers", () => {
it("builds dispatch options only from explicit selections", () => {
const descriptors = getProviderOptionDescriptors({
caps: codexCaps,
selections: [{ id: "fastMode", value: true }],
});
expect(buildExplicitProviderOptionSelectionsFromDescriptors(descriptors, undefined)).toBe(
undefined,
);
expect(
buildExplicitProviderOptionSelectionsFromDescriptors(descriptors, [
{ id: "fastMode", value: true },
]),
).toEqual([{ id: "fastMode", value: true }]);
});
it("dispatches an old Ultracode effort as Extra High with the Ultracode toggle", () => {
const legacy = [{ id: "effort", value: "ultracode" }];
const descriptors = getProviderOptionDescriptors({
caps: createModelCapabilities({
optionDescriptors: [
{
id: "effort",
label: "Reasoning",
type: "select",
options: [
{ id: "high", label: "High", isDefault: true },
{ id: "xhigh", label: "Extra High" },
],
},
{ id: "ultracode", label: "Ultracode", type: "boolean" },
],
}),
selections: legacy,
});
expect(buildExplicitProviderOptionSelectionsFromDescriptors(descriptors, legacy)).toEqual([
{ id: "effort", value: "xhigh" },
{ id: "ultracode", value: true },
]);
});
it("compares complete model selections independent of option ordering", () => {
const left = createModelSelection(ProviderInstanceId.make("codex"), "gpt-5.4", [
{ id: "reasoningEffort", value: "high" },
{ id: "fastMode", value: true },
]);
const reordered = createModelSelection(ProviderInstanceId.make("codex"), "gpt-5.4", [
{ id: "fastMode", value: true },
{ id: "reasoningEffort", value: "high" },
]);
expect(modelSelectionsEqual(left, reordered)).toBe(true);
expect(
modelSelectionsEqual(left, {
...reordered,
options: [
{ id: "fastMode", value: true },
{ id: "reasoningEffort", value: "medium" },
],
}),
).toBe(false);
expect(modelSelectionsEqual(left, { ...reordered, model: "gpt-5.5" })).toBe(false);
});
});
describe("applyClaudePromptEffortPrefix", () => {
it("keeps slash commands intact when ultrathink is selected", () => {
expect(applyClaudePromptEffortPrefix("/compact", "ultrathink")).toBe("/compact");
expect(applyClaudePromptEffortPrefix(" /compact keep recent errors ", "ultrathink")).toBe(
"/compact keep recent errors",
);
expect(applyClaudePromptEffortPrefix(" /review src/model.ts ", "ultrathink")).toBe(
"/review src/model.ts",
);
expect(applyClaudePromptEffortPrefix("/security-review", "ultrathink")).toBe(
"/security-review",
);
expect(applyClaudePromptEffortPrefix("/plugin:skill run", "ultrathink")).toBe(
"/plugin:skill run",
);
expect(applyClaudePromptEffortPrefix("/deploy.prod to staging", "ultrathink")).toBe(
"/deploy.prod to staging",
);
});
it("still adds the ultrathink prefix to ordinary prompts", () => {
expect(applyClaudePromptEffortPrefix("Investigate this failure", "ultrathink")).toBe(
"Ultrathink:\nInvestigate this failure",
);
expect(applyClaudePromptEffortPrefix("/home/theo/app.ts crashed on load", "ultrathink")).toBe(
"Ultrathink:\n/home/theo/app.ts crashed on load",
);
});
});
describe("readCustomModelEntries", () => {
const capabilities: ModelCapabilities = {
optionDescriptors: [
{
id: "effort",
label: "Reasoning",
type: "select",
options: [{ id: "high", label: "High", isDefault: true }],
currentValue: "high",
},
],
};
it("resolves bare slugs and entries, trimming and deduplicating on slug", () => {
expect(
readCustomModelEntries([
" bare ",
{ slug: "named", name: " Named ", capabilities },
"bare",
{ slug: "named", name: "Second" },
"",
{ name: "no slug" },
42,
]),
).toEqual([
{ slug: "bare", name: "bare", capabilities: null },
{ slug: "named", name: "Named", capabilities },
]);
});
it("drops unparseable capabilities but keeps the entry", () => {
expect(
readCustomModelEntries([{ slug: "x", capabilities: { optionDescriptors: "nope" } }]),
).toEqual([{ slug: "x", name: "x", capabilities: null }]);
expect(readCustomModelEntries("not a list")).toEqual([]);
});
});
describe("provider-reported option display", () => {
const selection = createModelSelection(ProviderInstanceId.make("opencode"), "ling");
const reported = { ...selection, options: [{ id: "variant", value: "default" }] };
const descriptor = {
id: "variant",
label: "Reasoning",
type: "select" as const,
options: [
{ id: "none", label: "None" },
{ id: "thinking", label: "Thinking" },
],
};
it("shows explicit reports without adding a choice or a dispatch option", () => {
expect(getProviderOptionCurrentLabel(descriptor, selection, reported)).toBe("Default");
expect(
getProviderOptionCurrentLabel(descriptor, selection, {
...reported,
options: [{ id: "variant", value: "thinking" }],
}),
).toBe("Thinking");
expect(
getProviderOptionCurrentLabel(
{ ...descriptor, currentValue: "none" },
{ ...selection, options: [{ id: "variant", value: "none" }] },
reported,
),
).toBe("None");
expect(descriptor.options.map((option) => option.id)).toEqual(["none", "thinking"]);
expect(buildProviderOptionSelectionsFromDescriptors([descriptor])).toBeUndefined();
expect(getProviderOptionCurrentLabel(descriptor, selection)).toBe("Unknown");
const effortDescriptor = { ...descriptor, id: "effort", currentValue: "default" };
expect(getProviderOptionCurrentLabel(effortDescriptor, selection)).toBeUndefined();
expect(
getProviderOptionCurrentLabel(effortDescriptor, selection, {
...reported,
model: "other",
options: [{ id: "effort", value: "default" }],
}),
).toBeUndefined();
expect(
getProviderOptionCurrentLabel(effortDescriptor, selection, {
...reported,
options: [{ id: "effort", value: "default" }],
}),
).toBe("Default");
expect(
getProviderOptionCurrentLabel({ ...descriptor, currentValue: "thinking" }, selection),
).toBe("Unknown");
});
it.each([
{ ...selection, model: "other" },
{ ...selection, instanceId: ProviderInstanceId.make("other") },
{ ...selection, options: [{ id: "variant", value: "none" }] },
])("ignores reports after changing the model, instance, or option: %j", (selected) => {
expect(getProviderOptionCurrentLabel(descriptor, selected, reported)).toBe("Unknown");
});
});