import { describe, expect, it } from "vite-plus/test";import { ProviderDriverKind, type ModelCapabilities } from "@t3tools/contracts"; import {  DESCRIPTOR_PRESETS_BY_KIND,  descriptorFromPreset,  definitionFromDraft,  descriptorsFromCapabilities,  draftFromDefinition,  validateDraft,  type CustomModelDraft,} from "./customModelEditor.logic"; const draft = (overrides: Partial<CustomModelDraft>): CustomModelDraft => ({  slug: "my-model",  name: "",  descriptors: [],  ...overrides,}); describe("customModelEditor.logic", () => {  it("round-trips a definition through the draft, marking the current value as default", () => {    const definition = definitionFromDraft(      draft({        name: " My Model ",        descriptors: [          {            key: "a",            type: "select",            id: "reasoningEffort",            label: "Reasoning",            choices: [              { key: "a1", id: "low", label: "Low", isDefault: false },              { key: "a2", id: "high", label: "", isDefault: true },            ],          },          { key: "b", type: "boolean", id: "fastMode", label: "Fast Mode", choices: [] },        ],      }),    );     expect(definition).toEqual({      slug: "my-model",      name: "My Model",      capabilities: {        optionDescriptors: [          {            id: "reasoningEffort",            label: "Reasoning",            type: "select",            options: [              { id: "low", label: "Low" },              { id: "high", label: "high", isDefault: true },            ],            currentValue: "high",          },          { id: "fastMode", label: "Fast Mode", type: "boolean" },        ],      },    });     const reopened = draftFromDefinition(definition);    expect(reopened.name).toBe("My Model");    expect(reopened.descriptors.map((descriptor) => descriptor.id)).toEqual([      "reasoningEffort",      "fastMode",    ]);    expect(reopened.descriptors[0]!.choices.map((choice) => choice.isDefault)).toEqual([      false,      true,    ]);  });   it("preserves the current choice when it differs from the built-in default", () => {    const descriptors = descriptorsFromCapabilities(      {        optionDescriptors: [          {            id: "effort",            label: "Reasoning",            type: "select",            currentValue: "high",            options: [              { id: "low", label: "Low", isDefault: true },              { id: "high", label: "High" },            ],          },        ],      },      ProviderDriverKind.make("claudeAgent"),    );    expect(descriptors[0]!.choices.map((choice) => choice.isDefault)).toEqual([false, true]);    expect(      definitionFromDraft(draft({ descriptors })).capabilities?.optionDescriptors?.[0],    ).toMatchObject({ currentValue: "high" });  });   it("drops prompt-injected choices when copying a built-in's descriptors", () => {    const [copied] = descriptorsFromCapabilities(      {        optionDescriptors: [          {            id: "effort",            label: "Reasoning",            type: "select",            options: [              { id: "high", label: "High", isDefault: true },              { id: "ultrathink", label: "Ultrathink" },            ],            promptInjectedValues: ["ultrathink"],          },        ],      },      ProviderDriverKind.make("claudeAgent"),    );    expect(copied!.choices.map((choice) => choice.id)).toEqual(["high"]);  });   it.each([true, false, undefined])(    "preserves boolean values through copy and edit: %s",    (currentValue) => {      const capabilities: ModelCapabilities = {        optionDescriptors: [          {            id: "thinking",            label: "Thinking",            type: "boolean",            ...(currentValue !== undefined ? { currentValue } : {}),          },        ],      };      const copied = definitionFromDraft(        draft({          descriptors: descriptorsFromCapabilities(capabilities, ProviderDriverKind.make("cursor")),        }),      );      expect(copied.capabilities).toEqual(capabilities);      const reopened = draftFromDefinition(copied);      expect(definitionFromDraft({ ...reopened, name: "Renamed" }).capabilities).toEqual(        capabilities,      );    },  );   it("excludes Claude context choices from presets and copies without changing other providers or authored entries", () => {    const capabilities: ModelCapabilities = {      optionDescriptors: [        {          id: "contextWindow",          label: "Context",          type: "select",          options: [{ id: "1m", label: "1M", isDefault: true }],        },        { id: "thinking", label: "Thinking", type: "boolean", currentValue: true },      ],    };    const claude = ProviderDriverKind.make("claudeAgent");    const copied = definitionFromDraft(      draft({ descriptors: descriptorsFromCapabilities(capabilities, claude) }),    );    expect(copied.capabilities?.optionDescriptors).toEqual([capabilities.optionDescriptors![1]]);    const presets = definitionFromDraft(      draft({        descriptors: (DESCRIPTOR_PRESETS_BY_KIND[claude] ?? []).map(descriptorFromPreset),      }),    );    expect(      presets.capabilities?.optionDescriptors?.some((option) => option.id === "contextWindow"),    ).toBe(false);    const cursorCopy = descriptorsFromCapabilities(capabilities, ProviderDriverKind.make("cursor"));    expect(cursorCopy.map((option) => option.id)).toEqual(["contextWindow", "thinking"]);    const authored = { slug: "custom", name: "Custom", capabilities };    expect(      definitionFromDraft(draftFromDefinition(authored)).capabilities?.optionDescriptors?.[0],    ).toMatchObject(capabilities.optionDescriptors![0]!);  });   it("preserves choice descriptions when copying, renaming, and saving", () => {    const capabilities: ModelCapabilities = {      optionDescriptors: [        {          id: "effort",          label: "Reasoning",          description: "Choose a reasoning level.",          type: "select",          options: [            { id: "high", label: "High", isDefault: true },            { id: "ultracode", label: "Ultracode", description: "Uses additional reasoning." },          ],        },      ],    };    const copied = definitionFromDraft(      draft({        descriptors: descriptorsFromCapabilities(          capabilities,          ProviderDriverKind.make("claudeAgent"),        ),      }),    );    const reopened = draftFromDefinition(copied);    const saved = definitionFromDraft({ ...reopened, name: "Renamed" });    expect(saved.capabilities?.optionDescriptors?.[0]).toMatchObject(      capabilities.optionDescriptors![0]!,    );    expect(copied.capabilities?.optionDescriptors?.[0]).toMatchObject(      capabilities.optionDescriptors![0]!,    );  });   it.each(Object.entries(DESCRIPTOR_PRESETS_BY_KIND))(    "offers saveable presets for %s",    (_driver, presets) => {      expect(        validateDraft(draft({ descriptors: (presets ?? []).map(descriptorFromPreset) })),      ).toBeNull();    },  );   it("collapses a blank name and no options back to a bare definition", () => {    expect(definitionFromDraft(draft({ name: "  " }))).toEqual({      slug: "my-model",      name: "my-model",      capabilities: null,    });    expect(draftFromDefinition({ slug: "x", name: "x", capabilities: null }).name).toBe("");  });   it("rejects duplicate ids, blank ids, and selects without choices", () => {    const select = (id: string, choices: Array<{ id: string }>) => ({      key: id,      type: "select" as const,      id,      label: "Label",      choices: choices.map((choice) => ({        key: choice.id,        label: "",        isDefault: false,        ...choice,      })),    });     expect(validateDraft(draft({ descriptors: [select("", [{ id: "a" }])] }))).toBe(      "Option 1 needs an id.",    );    expect(      validateDraft(        draft({ descriptors: [select("effort", [{ id: "a" }]), select("effort", [{ id: "b" }])] }),      ),    ).toBe('Option 2: id "effort" is used twice.');    expect(validateDraft(draft({ descriptors: [select("effort", [])] }))).toBe(      "Option 1 needs at least one choice.",    );    expect(      validateDraft(draft({ descriptors: [select("effort", [{ id: "a" }, { id: "a" }])] })),    ).toBe('Option 1: choice "a" is used twice.');    expect(validateDraft(draft({ descriptors: [select("effort", [{ id: "a" }])] }))).toBeNull();  });});