Skip to content

Your lightweight open-source personal agent.

92.2 KB
Raw Blame
import { act, fireEvent, screen, waitFor, within } from "@testing-library/react";
import { expect, it, vi } from "vitest";
import type { ProviderModelsPayload, SettingsPayload } from "@/lib/types";
import { requestMutationMock, jsonResponse, settingsPayload, renderSettingsView, openPopover, installSettingsViewTestHooks } from "@/tests/settings-test-utils";


function settingsPayloadWithBackup() {
  const base = settingsPayload();
  const backupPreset = {
    ...base.model_presets[0],
    name: "backup",
    label: "Backup",
    active: false,
    model: "anthropic/claude-sonnet-4",
    provider: "anthropic",
    resolved_provider: "anthropic",
  };
  return {
    backupPreset,
    payload: {
      ...base,
      model_presets: [base.model_presets[0], backupPreset],
      model_call_order: ["primary", "backup"],
      providers: [
        {
          name: "openai",
          label: "OpenAI",
          configured: true,
        },
        {
          name: "anthropic",
          label: "Anthropic",
          configured: true,
        },
      ],
    } satisfies SettingsPayload,
  };
}

function autoDynamicProviderPayload(
  options: {
    configured: boolean;
    hasApiKey: boolean;
    apiBase: string | null;
    apiKeyHint: string | null;
  },
): SettingsPayload {
  const base = settingsPayload();
  return {
    ...base,
    agent: {
      ...base.agent,
      model: "companyProxy/gpt-4o",
      provider: "companyProxy",
      resolved_provider: "companyProxy",
      has_api_key: options.hasApiKey,
    },
    model_presets: [
      {
        ...base.model_presets[0],
        model: "companyProxy/gpt-4o",
        provider: "auto",
        resolved_provider: "companyProxy",
      },
    ],
    providers: [
      {
        name: "companyProxy",
        label: "Company Proxy",
        configured: options.configured,
        auth_type: "api_key",
        api_key_required: false,
        api_key_hint: options.apiKeyHint,
        api_base: options.apiBase,
        default_api_base: null,
      },
    ],
  };
}

async function togglePresetEditor(name = "primary") {
  const row = await screen.findByTestId(`model-call-order-row-${name}`);
  fireEvent.click(within(row).getAllByRole("button")[0]);
}

function mockPresetRowLayout() {
  let top = 100;
  return screen.getAllByTestId(/^model-call-order-row-/).map((row, index) => {
    const rect = DOMRect.fromRect({ x: 0, y: top, width: 800, height: index === 0 ? 240 : 80 });
    vi.spyOn(row.closest('[role="listitem"]')!, "getBoundingClientRect").mockReturnValue(rect);
    top += rect.height + (index === 0 ? 72 : 8);
    return rect.top + rect.height / 2;
  });
}

async function openModelPicker() {
  const input = await screen.findByRole("combobox", { name: "Select model" });
  await openPopover(input);
  return input;
}

async function returnToPresetEditor() {
  const advanced = screen.queryByRole("dialog", { name: "Advanced options" });
  if (advanced) {
    fireEvent.click(within(advanced).getByRole("button", { name: "Close" }));
    await waitFor(() => expect(screen.queryByRole("dialog", { name: "Advanced options" })).not.toBeInTheDocument());
  }
}

function presetSaveButton() {
  return within(screen.getByTestId("model-preset-editor")).getByRole("button", { name: "Save", hidden: true });
}

async function openPresetAdvancedOptions() {
  await togglePresetEditor();
  fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
}

describe("Settings models", () => {
  installSettingsViewTestHooks();

  it("saves request overrides in a preset and restores inheritance when cleared", async () => {
    const payload = settingsPayload();
    payload.model_request_overrides_supported = true;
    payload.providers = [{ name: "openai", label: "OpenAI", configured: true, advanced_fields: ["extra_headers", "extra_body", "extra_query"] }];
    payload.model_presets[0].provider = "openai";
    vi.stubGlobal("fetch", vi.fn(async () => jsonResponse(payload)));
    requestMutationMock.mockImplementation(async (_action, args) => {
      if (args.extra_headers !== undefined) payload.model_presets[0].extra_headers = args.extra_headers ? JSON.parse(args.extra_headers) : null;
      return structuredClone(payload);
    });
    requestMutationMock.mockRejectedValueOnce(new Error("Could not save. Try again."));
    renderSettingsView({ initialSection: "models" });
    await openPresetAdvancedOptions();
    fireEvent.click(screen.getByRole("button", { name: "Headers Use provider settings Edit" }));
    let editor = screen.getByRole("dialog", { name: "Headers" });
    fireEvent.change(within(editor).getByRole("textbox", { name: "Headers" }), { target: { value: '{"X-Route":"preset"}' } });
    fireEvent.click(within(editor).getByRole("button", { name: "Save" }));
    expect(await within(editor).findByRole("alert")).toHaveTextContent("Could not save. Try again.");
    expect(within(editor).getByRole("textbox")).toHaveValue('{"X-Route":"preset"}');
    fireEvent.click(within(editor).getByRole("button", { name: "Save" }));
    await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
      "settings.model_configuration.update", { name: "primary", extra_headers: '{"X-Route":"preset"}' }, 20_000,
    ));
    fireEvent.click(await screen.findByRole("button", { name: "Headers Entries: 1 Edit" }));
    editor = screen.getByRole("dialog", { name: "Headers" });
    fireEvent.change(within(editor).getByRole("textbox", { name: "Headers" }), { target: { value: "" } });
    fireEvent.click(within(editor).getByRole("button", { name: "Save" }));
    await waitFor(() => expect(requestMutationMock).toHaveBeenLastCalledWith(
      "settings.model_configuration.update", { name: "primary", extra_headers: "" }, 20_000,
    ));
    expect(await screen.findByRole("button", { name: "Headers Use provider settings Edit" })).toBeEnabled();
  });

  it.each(["legacy", "declaration"])("saves and restores a preset API declaration, then returns to automatic (%s host)", async (host) => {
    let payload = settingsPayload();
    const provider: SettingsPayload["providers"][number] = {
      name: "openai", label: "OpenAI", configured: true,
    };
    if (host === "legacy") provider.model_api_configurable = true;
    else provider.request_apis = ["chat_completions", "responses"];
    payload.providers = [provider];
    payload.model_presets[0].provider = "openai";
    vi.stubGlobal("fetch", vi.fn(async () => jsonResponse(payload)));
    requestMutationMock.mockImplementation(async (action, args) => {
      expect(action).toBe("settings.model_configuration.update");
      payload = {
        ...payload,
        model_presets: payload.model_presets.map((preset) => ({ ...preset, api: args.api })),
      };
      return payload;
    });
    renderSettingsView({ initialSection: "models" });
    await togglePresetEditor();
    expect(screen.queryByRole("combobox", { name: "API connection" })).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    await openPopover(screen.getByLabelText("API connection"));
    expect(screen.getAllByRole("option")).toHaveLength(3);
    fireEvent.click(screen.getByRole("option", { name: "Responses" }));
    expect(screen.getByRole("switch", { name: "Try Chat Completions if Responses is unsupported" })).not.toBeChecked();
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenLastCalledWith(
      "settings.model_configuration.update",
      { name: "primary", api: { supported_apis: ["responses"], preferred_api: "responses" } },
      20_000,
    ));
    await waitFor(() => expect(presetSaveButton()).toBeDisabled());
    fireEvent.click(screen.getByRole("button", { name: "Close" }));
    await openPresetAdvancedOptions();
    expect(screen.getByLabelText("API connection")).toHaveTextContent("Responses");
    fireEvent.click(screen.getByRole("switch", { name: "Try Chat Completions if Responses is unsupported" }));
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenLastCalledWith(
      "settings.model_configuration.update",
      { name: "primary", api: { supported_apis: ["responses", "chat_completions"], preferred_api: "responses" } },
      20_000,
    ));
    await waitFor(() => expect(presetSaveButton()).toBeDisabled());
    fireEvent.click(screen.getByRole("button", { name: "Close" }));
    await openPresetAdvancedOptions();
    expect(screen.getByRole("switch", { name: "Try Chat Completions if Responses is unsupported" })).toBeChecked();
    await openPopover(screen.getByLabelText("API connection"));
    fireEvent.click(screen.getByRole("option", { name: "Responses" }));
    expect(screen.getByRole("switch", { name: "Try Chat Completions if Responses is unsupported" })).toBeChecked();
    expect(presetSaveButton()).toBeDisabled();
    await openPopover(screen.getByLabelText("API connection"));
    fireEvent.click(screen.getByRole("option", { name: "Auto" }));
    expect(screen.queryByRole("switch", { name: "Try Chat Completions if Responses is unsupported" })).not.toBeInTheDocument();
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenLastCalledWith(
      "settings.model_configuration.update", { name: "primary", api: null }, 20_000,
    ));
    expect(vi.mocked(fetch).mock.calls.some(([url]) => String(url).includes("/model-api?"))).toBe(false);
  });

  it("saves and restores Anthropic Messages for a custom gateway", async () => {
    let payload = settingsPayload();
    payload.providers = [{
      name: "tenant", label: "Tenant", configured: true,
      request_apis: ["chat_completions", "responses", "anthropic_messages"],
    }];
    payload.model_presets[0].provider = "tenant";
    payload.model_presets[0].resolved_provider = "tenant";
    vi.stubGlobal("fetch", vi.fn(async () => jsonResponse(payload)));
    requestMutationMock.mockImplementation(async (action, args) => {
      expect(action).toBe("settings.model_configuration.update");
      payload = {
        ...payload,
        model_presets: payload.model_presets.map((preset) => ({ ...preset, api: args.api })),
      };
      return payload;
    });
    renderSettingsView({ initialSection: "models" });
    await openPresetAdvancedOptions();
    await openPopover(screen.getByLabelText("API connection"));
    expect(screen.getAllByRole("option")).toHaveLength(4);
    fireEvent.click(screen.getByRole("option", { name: "Anthropic Messages" }));
    expect(screen.queryByRole("switch", { name: "Try Chat Completions if Responses is unsupported" })).not.toBeInTheDocument();
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenLastCalledWith(
      "settings.model_configuration.update",
      { name: "primary", api: { supported_apis: ["anthropic_messages"], preferred_api: "anthropic_messages" } },
      20_000,
    ));
    await waitFor(() => expect(presetSaveButton()).toBeDisabled());
    fireEvent.click(screen.getByRole("button", { name: "Close" }));
    await openPresetAdvancedOptions();
    expect(screen.getByLabelText("API connection")).toHaveTextContent("Anthropic Messages");
    expect(presetSaveButton()).toBeDisabled();
    await openPopover(screen.getByLabelText("API connection"));
    fireEvent.click(screen.getByRole("option", { name: "Responses" }));
    expect(screen.getByRole("switch", { name: "Try Chat Completions if Responses is unsupported" })).not.toBeChecked();
  });

  it("saves an explicit API after an Auto provider resolves the changed model to a new connection", async () => {
    const payload = settingsPayload();
    payload.model_api_resolution_supported = true;
    payload.model_presets[0] = {
      ...payload.model_presets[0], provider: "auto", model: "anthropic/claude-sonnet-4",
      resolved_provider: "anthropic",
    };
    payload.providers = [
      { name: "anthropic", label: "Anthropic", configured: true, request_apis: ["anthropic_messages"] },
      { name: "openai", label: "OpenAI", configured: true, request_apis: ["chat_completions", "responses"] },
    ];
    vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
      const url = new URL(String(input), "http://localhost");
      if (url.pathname !== "/api/settings/model-api") return jsonResponse(payload);
      return jsonResponse(url.searchParams.get("model")?.startsWith("gpt")
        ? { provider: "openai", api: "chat_completions" }
        : { provider: "anthropic", api: "anthropic_messages" });
    }));
    requestMutationMock.mockImplementation(async (_action, args) => {
      payload.model_presets = payload.model_presets.map((preset) => preset.name !== args.name ? preset : {
        ...preset, model: args.model ?? preset.model, api: args.api ?? preset.api,
      });
      return { ...payload };
    });
    renderSettingsView({ initialSection: "models", initialSettings: payload });
    await openPresetAdvancedOptions();
    await returnToPresetEditor();
    const search = await openModelPicker();
    fireEvent.change(search, { target: { value: "gpt-4o" } });
    fireEvent.keyDown(search, { key: "Enter" });
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    await waitFor(() => expect(screen.getByLabelText("API connection")).toHaveTextContent("Auto (Chat Completions)"));
    await openPopover(screen.getByLabelText("API connection"));
    fireEvent.click(screen.getByRole("option", { name: "Responses" }));
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
      "settings.model_configuration.update", {
        name: "primary",
        api: { supported_apis: ["responses"], preferred_api: "responses" },
      }, 20_000,
    ));
  });

  it("shows the host's automatic API and discards an older reasoning resolution", async () => {
    const payload = settingsPayload();
    payload.model_api_resolution_supported = true;
    payload.model_presets[0].provider = "openai";
    payload.providers = [{
      name: "openai", label: "OpenAI", configured: true,
      request_apis: ["chat_completions", "responses"],
    }];
    let finishHigh!: (response: Response) => void;
    const highResponse = new Promise<Response>((resolve) => { finishHigh = resolve; });
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = new URL(String(input), "http://localhost");
      if (url.pathname !== "/api/settings/model-api") return jsonResponse(payload);
      if (url.searchParams.get("reasoning_effort") === "high") return highResponse;
      return jsonResponse({ provider: "openai", api: "chat_completions" });
    });
    vi.stubGlobal("fetch", fetchMock);
    requestMutationMock.mockImplementation(async (_action, args) => {
      payload.model_presets = payload.model_presets.map((preset) => ({
        ...preset, reasoning_effort: args.reasoning_effort ?? preset.reasoning_effort,
      }));
      return { ...payload };
    });
    renderSettingsView({ initialSection: "models" });
    await openPresetAdvancedOptions();
    await waitFor(() => expect(screen.getByLabelText("API connection")).toHaveTextContent("Auto (Chat Completions)"));
    expect(presetSaveButton()).toBeDisabled();
    await openPopover(screen.getByLabelText("API connection"));
    expect(screen.getByRole("option", { name: "Auto (Chat Completions)" })).toHaveAttribute("aria-selected", "true");
    fireEvent.click(screen.getByRole("option", { name: "Auto (Chat Completions)" }));
    await returnToPresetEditor();
    fireEvent.change(screen.getByLabelText("Reasoning effort"), { target: { value: "high" } });
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    await waitFor(() => expect(fetchMock.mock.calls.some(([url]) => String(url).includes("reasoning_effort=high"))).toBe(true));
    await returnToPresetEditor();
    fireEvent.change(screen.getByLabelText("Reasoning effort"), { target: { value: "none" } });
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    await waitFor(() => expect(fetchMock.mock.calls.some(([url]) => String(url).includes("reasoning_effort=none"))).toBe(true));
    await waitFor(() => expect(screen.getByLabelText("API connection")).toHaveTextContent("Auto (Chat Completions)"));
    await act(async () => { finishHigh(jsonResponse({ provider: "openai", api: "responses" })); });
    expect(screen.getByLabelText("API connection")).toHaveTextContent("Auto (Chat Completions)");
    expect(requestMutationMock).toHaveBeenCalledWith(
      "settings.model_configuration.update", { name: "primary", reasoning_effort: "high" }, 20_000,
    );
  });

  it("updates the Auto label from a valid host result without changing the preset declaration", async () => {
    const payload = settingsPayload();
    payload.model_api_resolution_supported = true;
    payload.model_presets[0].provider = "openai";
    payload.providers = [{
      name: "openai", label: "OpenAI", configured: true,
      request_apis: ["chat_completions", "responses"],
    }];
    vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
      const url = new URL(String(input), "http://localhost");
      if (url.pathname !== "/api/settings/model-api") return jsonResponse(payload);
      return jsonResponse({
        provider: "openai", api: url.searchParams.get("reasoning_effort") === "high" ? "responses" : "chat_completions",
      });
    }));
    renderSettingsView({ initialSection: "models" });
    await openPresetAdvancedOptions();
    await waitFor(() => expect(screen.getByLabelText("API connection")).toHaveTextContent("Auto (Chat Completions)"));
    await returnToPresetEditor();
    fireEvent.change(screen.getByLabelText("Reasoning effort"), { target: { value: "high" } });
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    await waitFor(() => expect(screen.getByLabelText("API connection")).toHaveTextContent("Auto (Responses)"));
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
      "settings.model_configuration.update", { name: "primary", reasoning_effort: "high" }, 20_000,
    ));
  });

  it.each(["future_api", null])("leaves the automatic API unconfirmed for an unsupported host result (%s)", async (api) => {
    const payload = settingsPayload();
    payload.model_api_resolution_supported = true;
    payload.providers = [{
      name: "openai", label: "OpenAI", configured: true,
      request_apis: ["chat_completions", "responses"],
    }];
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => String(input).includes("/model-api?")
      ? jsonResponse({ provider: "openai", api }) : jsonResponse(payload));
    vi.stubGlobal("fetch", fetchMock);
    renderSettingsView({ initialSection: "models" });
    await openPresetAdvancedOptions();
    await waitFor(() => expect(fetchMock.mock.calls.some(([url]) => String(url).includes("/model-api?"))).toBe(true));
    await act(async () => { await Promise.resolve(); });
    expect(screen.getByLabelText("API connection")).toHaveTextContent(/^Auto$/);
    expect(presetSaveButton()).toBeDisabled();
  });

  it.each([undefined, ["future_api"], ["future_api", "future_api_v2"], "responses"])("hides API controls when host support is unconfirmed (%s)", async (requestAPIs) => {
    const payload = settingsPayload();
    vi.stubGlobal("fetch", vi.fn(async () => jsonResponse({
      ...payload,
      providers: [{ name: "openai", label: "OpenAI", configured: true, request_apis: requestAPIs }],
    })));
    renderSettingsView({ initialSection: "models" });
    await openPresetAdvancedOptions();
    expect(screen.queryByRole("combobox", { name: "API connection" })).not.toBeInTheDocument();
  });

  it("uses the host's API declaration and preserves an existing Chat preference when renaming", async () => {
    const payload = settingsPayload();
    payload.providers = [{
      name: "openai", label: "OpenAI", configured: true,
      request_apis: ["chat_completions", "responses"],
    }];
    payload.model_presets[0].api = {
      supported_apis: ["chat_completions", "responses"], preferred_api: "chat_completions",
    };
    vi.stubGlobal("fetch", vi.fn(async () => jsonResponse(payload)));
    requestMutationMock.mockResolvedValue(payload);
    renderSettingsView({ initialSection: "models" });
    await togglePresetEditor();
    expect(screen.queryByRole("combobox", { name: "API connection" })).not.toBeInTheDocument();
    expect(screen.getByRole("button", { name: /Advanced options/ })).toHaveAttribute("aria-expanded", "false");
    expect(presetSaveButton()).toBeDisabled();
    fireEvent.change(screen.getByLabelText("Preset name"), { target: { value: "Renamed" } });
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
      "settings.model_configuration.update", { name: "primary", new_name: "Renamed" }, 20_000,
    ));
  });

  it.each([
    ["openai_codex", "OpenAI Codex", "responses", "Responses"],
    ["anthropic", "Anthropic", "anthropic_messages", "Anthropic Messages"],
    ["bedrock", "AWS Bedrock", "bedrock_converse", "Bedrock Converse"],
  ] as const)("shows the fixed connection for %s", async (provider, label, api, apiLabel) => {
    const payload = settingsPayload();
    payload.providers = [{ name: provider, label, configured: true, request_apis: [api] }];
    payload.model_presets[0].provider = provider;
    payload.model_presets[0].resolved_provider = provider;
    vi.stubGlobal("fetch", vi.fn(async () => jsonResponse(payload)));
    renderSettingsView({ initialSection: "models" });
    await openPresetAdvancedOptions();
    expect(screen.getByText(apiLabel, { exact: true })).toBeVisible();
    expect(screen.queryByRole("combobox", { name: "API connection" })).not.toBeInTheDocument();
    expect(screen.queryByRole("switch")).not.toBeInTheDocument();
    expect(presetSaveButton()).toBeDisabled();
  });

  it.each(["manual", "poll", "direct"])("reauthenticates from the catalog and preserves the preset draft (%s)", async (mode) => {
    const payload = settingsPayload();
    payload.providers = [{
      name: "openai_codex", label: "OpenAI Codex", configured: true,
      auth_type: "oauth", model_catalog: "hybrid", oauth_login_supported: true,
    }];
    let recovered = false;
    const signedIn = () => {
      recovered = true;
      return { ...payload, providers: payload.providers.map((row) => ({ ...row })) };
    };
    requestMutationMock.mockImplementation(async (action, args) => {
      if (action === "settings.provider.oauth_login") {
        return mode === "direct" ? signedIn() : {
          status: "authorization_required", provider: "openai_codex", flow_id: "flow-test",
          authorization_url: "https://example.com/authorize", expires_in: 600,
          completion_input: "callback_url",
        };
      }
      if (action === "settings.provider.oauth_complete") {
        return mode === "manual" && !args.authorization_response
          ? { status: "pending", provider: "openai_codex", flow_id: "flow-test" }
          : signedIn();
      }
      throw new Error(`Unexpected mutation: ${action}`);
    });
    vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
      if (String(input).includes("/provider-models?")) return jsonResponse({
        provider: "openai_codex", label: "OpenAI Codex", status: "available", catalog_kind: "hybrid",
        source: recovered ? "remote" : "fallback", error_kind: recovered ? null : "auth_required",
        models: [{ id: recovered ? "openai-codex/new-model" : "openai-codex/offline-model" }], model_count: 1,
      });
      return jsonResponse(payload);
    }));
    renderSettingsView({ initialSection: "models" });
    fireEvent.click(await screen.findByRole("button", { name: "New preset" }));
    fireEvent.change(screen.getByRole("textbox", { name: "Preset name" }), {
      target: { value: "My unsaved preset" },
    });
    await openModelPicker();
    fireEvent.click(await screen.findByRole("button", { name: "Sign in again" }));
    if (mode === "manual") {
      fireEvent.change(await screen.findByRole("textbox", { name: "Callback URL" }), {
        target: { value: "http://localhost:1455/auth/callback?code=fixture&state=test" },
      });
      fireEvent.click(screen.getByRole("button", { name: "Finish sign-in" }));
    }
    await waitFor(() => expect(recovered).toBe(true), { timeout: 3000 });
    expect(screen.getByRole("textbox", { name: "Preset name" })).toHaveValue("My unsaved preset");
    await openModelPicker();
    expect(await screen.findByRole("option", { name: /openai-codex\/new-model/ })).toBeVisible();
    expect(screen.queryByText("Authorization expired. Please sign in again.")).not.toBeInTheDocument();
    expect(requestMutationMock.mock.calls.every(([action]) => action.startsWith("settings.provider.oauth_"))).toBe(true);
  });

  it("uses the preset name as the canonical identity", async () => {
    const payload = settingsPayload();
    payload.model_presets[0] = {
      ...payload.model_presets[0],
      name: "openai",
      label: "minimax",
    };
    payload.model_call_order = ["openai"];
    payload.agent.model_preset = "openai";
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));

    renderSettingsView({ initialSection: "models", initialSettings: payload });

    await togglePresetEditor("openai");

    const editor = screen.getByTestId("model-preset-editor");
    expect(within(editor).getByText("Preset name")).toBeInTheDocument();
    expect(within(editor).getByRole("textbox", { name: "Preset name" })).toHaveValue(
      "openai",
    );
  });

  it("edits a legacy case-conflicting preset without treating its own name as a rename", async () => {
    const payload = settingsPayload();
    const primary = {
      ...payload.model_presets[0],
      name: "Fast",
      label: "Fast",
      active: true,
    };
    const legacyConflict = {
      ...primary,
      name: "fast",
      label: "fast",
      active: false,
    };
    const legacyPayload: SettingsPayload = {
      ...payload,
      agent: { ...payload.agent, model_preset: "Fast" },
      model_presets: [primary, legacyConflict],
      model_call_order: ["Fast", "fast"],
    };
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));
    requestMutationMock.mockResolvedValueOnce(legacyPayload);

    renderSettingsView({ initialSection: "models", initialSettings: legacyPayload });
    await togglePresetEditor("Fast");
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    fireEvent.change(screen.getByLabelText("Temperature"), {
      target: { value: "0.4" },
    });
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());

    await waitFor(() => {
      expect(requestMutationMock).toHaveBeenCalledWith(
        "settings.model_configuration.update",
        { name: "Fast", temperature: 0.4 },
        20_000,
      );
    });
  });

  it("renames an existing preset without losing the editor selection", async () => {
    const payload = settingsPayload();
    const renamedPayload: SettingsPayload = {
      ...payload,
      agent: { ...payload.agent, model_preset: "Codex" },
      model_presets: payload.model_presets.map((preset) => ({
        ...preset,
        name: "Codex",
        label: "Codex",
      })),
      model_call_order: ["Codex"],
    };
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));
    requestMutationMock.mockResolvedValueOnce(renamedPayload);

    renderSettingsView({ initialSection: "models", initialSettings: payload });
    await togglePresetEditor();

    const nameInput = screen.getByRole("textbox", { name: "Preset name" });
    fireEvent.change(nameInput, { target: { value: "Codex" } });
    fireEvent.blur(nameInput);
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());

    await waitFor(() => {
      expect(requestMutationMock).toHaveBeenCalledWith(
        "settings.model_configuration.update",
        { name: "primary", new_name: "Codex" },
        20_000,
      );
    });
    expect(await screen.findByTestId("model-call-order-row-Codex")).toBeInTheDocument();
    expect(screen.getByRole("textbox", { name: "Preset name" })).toHaveValue("Codex");
  });

  it("maps a server-side name conflict back to the preset name field", async () => {
    const payload = settingsPayload();
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));
    requestMutationMock.mockRejectedValueOnce({ status: 409 });

    renderSettingsView({ initialSection: "models", initialSettings: payload });
    await togglePresetEditor();

    const nameInput = screen.getByRole("textbox", { name: "Preset name" });
    fireEvent.change(nameInput, { target: { value: "Codex" } });
    fireEvent.blur(nameInput);
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());

    expect(await screen.findByRole("alert")).toHaveTextContent(
      "A preset with this name already exists.",
    );
    expect(nameInput).toHaveAttribute("aria-invalid", "true");
    expect(nameInput).toHaveFocus();
  });

  it("opens generation parameters in the advanced options dialog", async () => {
    vi.stubGlobal(
      "fetch",
      vi.fn(async (input: RequestInfo | URL) => {
        const url = String(input);
        if (url === "/api/settings") return jsonResponse(settingsPayload());
        if (url === "/api/settings/cli-apps") {
          return jsonResponse({ apps: [], installed_count: 0 });
        }
        if (url === "/api/settings/mcp-presets") {
          return jsonResponse({ presets: [], installed_count: 0 });
        }
        return { ok: false, status: 404, json: async () => ({}) } as Response;
      }),
    );

    renderSettingsView({ initialSection: "models" });

    await togglePresetEditor();
    const advanced = await screen.findByRole("button", { name: /Advanced options/ });

    fireEvent.click(advanced);

    expect(within(screen.getByRole("dialog", { name: "Advanced options" })).getByText("Context window")).toBeInTheDocument();
    expect(screen.getByText("Temperature")).toBeInTheDocument();
    expect(screen.getByRole("textbox", { name: "Context window" })).toHaveValue("200k");
    await returnToPresetEditor();
    const reasoningEffort = screen.getByLabelText("Reasoning effort");
    expect(reasoningEffort).toHaveProperty("type", "text");
    fireEvent.change(reasoningEffort, { target: { value: "provider-native-mode" } });
    expect(reasoningEffort).toHaveValue("provider-native-mode");
  });

  it.each([["128000", 128000, "128k"], ["131072", 131072, "131072"], ["272k", 272000, "272k"], ["256K", 256000, "256k"], ["1.5m", 1500000, "1500k"], ["1.001k", 1001, "1001"]] as const)("saves a custom context budget (%s)", async (input, tokens, restored) => {
    const payload = settingsPayload();
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));
    requestMutationMock.mockResolvedValue({
      ...payload,
      model_presets: payload.model_presets.map((preset) => ({ ...preset, context_window_tokens: tokens })),
    });
    renderSettingsView({ initialSection: "models", initialSettings: payload });
    await togglePresetEditor();
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    fireEvent.change(screen.getByRole("textbox", { name: "Context window" }), {
      target: { value: input },
    });
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
      "settings.model_configuration.update", expect.objectContaining({ context_window_tokens: tokens }), expect.any(Number),
    ));
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    expect(screen.getByRole("textbox", { name: "Context window" })).toHaveValue(restored);
  });

  it.each(["", "0", "-1", "1.5", "abc", "2ki", "0.0001k", "9007199254740992"])("keeps invalid context input unsaved (%s)", async (value) => {
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));
    renderSettingsView({ initialSection: "models", initialSettings: settingsPayload() });
    await togglePresetEditor();
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    const input = screen.getByRole("textbox", { name: "Context window" });
    vi.useFakeTimers();
    fireEvent.change(input, { target: { value } });
    expect(input).toHaveAttribute("aria-invalid", "true");
    expect(input).toHaveAccessibleDescription("Enter a positive token count, such as 200k, 1m, or 131072.");
    await act(() => vi.advanceTimersByTimeAsync(750));
    vi.useRealTimers();
    expect(requestMutationMock).not.toHaveBeenCalled();
    expect(input).toHaveValue(value);
    fireEvent.click(screen.getByRole("button", { name: "Close" }));
    await act(async () => {});
    expect(screen.getByRole("dialog", { name: "Advanced options" })).toContainElement(input);
    expect(presetSaveButton()).toBeDisabled();
  });

  it("saves abbreviated output budgets as integers and keeps an incomplete input unsaved", async () => {
    let payload = settingsPayload();
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));
    requestMutationMock.mockImplementation(async (_action, args) => {
      payload = {
        ...payload,
        model_presets: payload.model_presets.map((preset) => ({ ...preset, max_tokens: args.max_tokens })),
      };
      return payload;
    });
    renderSettingsView({ initialSection: "models", initialSettings: payload });
    await openPresetAdvancedOptions();
    let input = screen.getByRole("textbox", { name: "Max output tokens" });
    fireEvent.change(input, { target: { value: "32K" } });
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenLastCalledWith(
      "settings.model_configuration.update", expect.objectContaining({ max_tokens: 32000 }), expect.any(Number),
    ));
    await waitFor(() => expect(presetSaveButton()).toBeDisabled());
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    input = screen.getByRole("textbox", { name: "Max output tokens" });
    expect(input).toHaveValue("32k");
    requestMutationMock.mockClear();
    vi.useFakeTimers();
    fireEvent.change(input, { target: { value: "" } });
    expect(input).toHaveAttribute("aria-invalid", "true");
    expect(presetSaveButton()).toBeDisabled();
    await act(() => vi.advanceTimersByTimeAsync(750));
    vi.useRealTimers();
    expect(requestMutationMock).not.toHaveBeenCalled();
    fireEvent.change(input, { target: { value: "8.192k" } });
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenLastCalledWith(
      "settings.model_configuration.update", expect.objectContaining({ max_tokens: 8192 }), expect.any(Number),
    ));
  });

  it("opens the preset editor in a dialog and protects the primary preset", async () => {
    vi.stubGlobal(
      "fetch",
      vi.fn(async (input: RequestInfo | URL) => {
        const url = String(input);
        if (url === "/api/settings") return jsonResponse(settingsPayload());
        if (url === "/api/settings/cli-apps") {
          return jsonResponse({ apps: [], installed_count: 0 });
        }
        if (url === "/api/settings/mcp-presets") {
          return jsonResponse({ presets: [], installed_count: 0 });
        }
        return { ok: false, status: 404, json: async () => ({}) } as Response;
      }),
    );

    renderSettingsView({ initialSection: "models" });

    const row = await screen.findByTestId("model-call-order-row-primary");
    const trigger = within(row).getAllByRole("button")[0];
    expect(trigger).toHaveAttribute("aria-haspopup", "dialog");

    fireEvent.click(trigger);

    const editor = screen.getByTestId("model-preset-editor");
    expect(trigger).toHaveAttribute("aria-pressed", "true");
    expect(row.closest('[role="listitem"]')).toBeInTheDocument();
    expect(row.closest('[role="list"]')).toBeInTheDocument();
    expect(screen.getByRole("dialog", { name: "primary" })).toContainElement(editor);
    expect(within(editor).getByRole("textbox", { name: "Preset name" })).toHaveValue(
      "primary",
    );
    const deleteButton = within(editor).getByRole("button", { name: "Delete" });
    expect(deleteButton).toBeDisabled();
    expect(deleteButton).toHaveAttribute("aria-describedby", "model-preset-delete-hint");
    expect(
      within(editor).getByText("Cannot delete the primary model"),
    ).toBeInTheDocument();

    fireEvent.click(screen.getByRole("button", { name: "Close" }));
  });

  it("opens advanced options in a separate dialog and preserves the preset draft", async () => {
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));
    const payload = settingsPayload();
    requestMutationMock.mockResolvedValue({
      ...payload, model_presets: payload.model_presets.map((preset) => ({ ...preset, context_window_tokens: 128000 })),
    });
    renderSettingsView({ initialSection: "models", initialSettings: payload });
    await togglePresetEditor();
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    const advanced = screen.getByRole("dialog", { name: "Advanced options" });
    fireEvent.change(within(advanced).getByLabelText("Context window"), { target: { value: "128k" } });
    fireEvent.click(within(advanced).getByRole("button", { name: "Close" }));
    await waitFor(() => expect(screen.queryByRole("dialog", { name: "Advanced options" })).not.toBeInTheDocument());
    expect(screen.getByTestId("model-preset-editor")).toBeVisible();
    expect(requestMutationMock).toHaveBeenCalledTimes(1);
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    expect(within(screen.getByRole("dialog", { name: "Advanced options" })).getByLabelText("Context window")).toHaveValue("128k");
  });

  it.each([true, false])("closes the preset editor only after deletion succeeds (success: %s)", async (success) => {
    const { payload } = settingsPayloadWithBackup();
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));
    if (success) requestMutationMock.mockResolvedValueOnce({
      ...payload,
      model_presets: payload.model_presets.filter((preset) => preset.name !== "backup"),
      model_call_order: ["primary"],
    });
    else requestMutationMock.mockRejectedValueOnce(new Error("Delete failed"));
    renderSettingsView({ initialSection: "models", initialSettings: payload });
    fireEvent.click(within(screen.getByTestId("model-call-order-row-backup")).getByRole("button", { name: "Configure" }));
    fireEvent.click(within(screen.getByTestId("model-preset-editor")).getByRole("button", { name: "Delete" }));
    const confirmation = screen.getByRole("dialog", { name: "Delete model preset?" });
    fireEvent.click(within(confirmation).getByRole("button", { name: "Delete" }));
    await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
      "settings.model_configuration.delete", { name: "backup" }, 20_000,
    ));
    if (success) {
      await waitFor(() => expect(screen.queryByTestId("model-preset-editor")).not.toBeInTheDocument());
      expect(screen.queryByTestId("model-call-order-row-backup")).not.toBeInTheDocument();
    } else {
      await waitFor(() => expect(within(confirmation).getByRole("button", { name: "Delete" })).toBeEnabled());
      expect(screen.getByTestId("model-preset-editor")).toBeInTheDocument();
    }
  });

  it.each([true, false])("shows a saved primary summary inside the shared settings layout (sidebar: %s)", async (showSidebar) => {
    const payload = settingsPayload();
    payload.model_presets[0].context_window_tokens = 262_144;
    payload.model_presets[0].max_tokens = 32_768;
    renderSettingsView({ initialSection: "models", initialSettings: payload, showSidebar });

    expect(screen.queryAllByRole("heading", { name: "Models" })).toHaveLength(showSidebar ? 0 : 1);
    expect(screen.getByRole("heading", { name: "Model presets" })).toHaveClass("settings-section-title");
    expect(screen.queryByRole("heading", { name: "Fallback presets" })).not.toBeInTheDocument();
    const summary = within(screen.getByTestId("model-call-order-row-primary"));
    expect(summary.getByText(payload.model_presets[0].model)).toBeInTheDocument();
    expect(summary.getByText("256K Default")).toBeInTheDocument();

    await togglePresetEditor();
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    fireEvent.change(screen.getByLabelText("Context window"), { target: { value: "128k" } });
    expect(summary.getByText("256K Default")).toBeInTheDocument();
  });

  it("shows each preset's own summary before and after changing the primary", async () => {
    const { payload } = settingsPayloadWithBackup();
    payload.model_presets[0].context_window_tokens = 262_144;
    payload.model_presets[1].context_window_tokens = 128_000;
    payload.model_presets[1].reasoning_effort = "xhigh";
    const disabledPreset = {
      ...payload.model_presets[1],
      name: "disabled",
      model: "openai/other-model",
      context_window_tokens: 1_048_576,
      reasoning_effort: "none",
    };
    payload.model_presets.push(disabledPreset);
    requestMutationMock.mockResolvedValueOnce({ ...payload, model_call_order: ["backup", "primary"] });
    renderSettingsView({ initialSection: "models", initialSettings: payload });

    const expectSummaries = () => {
      for (const [name, model, settings] of [
        ["primary", payload.model_presets[0].model, "256K Default"],
        ["backup", payload.model_presets[1].model, "128K xhigh"],
        ["disabled", disabledPreset.model, "1M none"],
      ]) {
        const row = within(screen.getByTestId(`model-call-order-row-${name}`));
        expect(row.getByText(model)).toBeInTheDocument();
        expect(row.getByText(settings)).toBeInTheDocument();
      }
    };
    expectSummaries();
    fireEvent.keyDown(screen.getByTestId("model-call-order-row-backup"), { key: "ArrowUp" });
    await waitFor(() => expect(within(screen.getByTestId("model-call-order-row-backup"))
      .getByText("Primary")).toBeInTheDocument());
    expect(requestMutationMock).toHaveBeenCalledWith(
      "settings.model_call_order.update", { order: ["backup", "primary"] }, 20_000,
    );
    expectSummaries();
  });

  it.each([
    ["backup", 1, 0],
    ["primary", 0, 1],
  ] as const)("drags %s across different row heights and saves the model call order immediately", async (name, from, to) => {
    const { payload, backupPreset } = settingsPayloadWithBackup();
    const updatedPayload: SettingsPayload = {
      ...payload,
      agent: {
        ...payload.agent,
        model: backupPreset.model,
        provider: backupPreset.provider,
        resolved_provider: backupPreset.resolved_provider,
        model_preset: backupPreset.name,
      },
      model_presets: payload.model_presets.map((preset) => ({
        ...preset,
        active: preset.name === backupPreset.name,
        temperature: preset.name === "primary" ? 0.4 : preset.temperature,
      })),
      model_call_order: ["backup", "primary"],
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return jsonResponse(payload);
      if (url === "/api/settings/cli-apps") {
        return jsonResponse({ apps: [], installed_count: 0 });
      }
      if (url === "/api/settings/mcp-presets") {
        return jsonResponse({ presets: [], installed_count: 0 });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);
    requestMutationMock.mockResolvedValueOnce({
      ...payload, model_presets: payload.model_presets.map((preset) => preset.name === "primary" ? { ...preset, temperature: 0.4 } : preset),
    }).mockResolvedValueOnce(updatedPayload);

    renderSettingsView({ initialSection: "models", initialSettings: payload });

    await waitFor(() =>
      expect(fetchMock).toHaveBeenCalledWith(
        "/api/settings",
        expect.objectContaining({
          headers: { Authorization: "Bearer tok" },
        }),
      ),
    );
    await togglePresetEditor();
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    fireEvent.change(screen.getByLabelText("Temperature"), {
      target: { value: "0.4" },
    });
    await returnToPresetEditor();
    fireEvent.click(screen.getByRole("button", { name: "Close" }));
    await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());
    requestMutationMock.mockClear();
    const centers = mockPresetRowLayout();
    const draggedRow = screen.getByTestId(`model-call-order-row-${name}`);
    fireEvent.pointerDown(draggedRow, { button: 0, clientY: centers[from], pointerId: 1 });
    fireEvent.pointerMove(draggedRow, { clientY: centers[to] + (to > from ? 1 : -1), pointerId: 1, buttons: 1 });
    expect(within(screen.getByTestId("model-call-order-row-backup")).getByText("Primary")).toBeInTheDocument();
    expect(requestMutationMock).not.toHaveBeenCalled();
    fireEvent.pointerUp(draggedRow, { pointerId: 1 });
    fireEvent.click(draggedRow);

    await waitFor(() => {
      expect(requestMutationMock).toHaveBeenCalledWith(
        "settings.model_call_order.update",
        { order: ["backup", "primary"] },
        20_000,
      );
    });

    const newPrimary = screen.getByTestId("model-call-order-row-backup");
    expect(within(newPrimary).getByText("Primary")).toBeInTheDocument();
    expect(within(newPrimary).getByText(backupPreset.model)).toBeInTheDocument();
    expect(within(newPrimary).getByText("200K Default")).toBeInTheDocument();
    fireEvent.click(within(screen.getByTestId("model-call-order-row-primary")).getByRole("button", { name: "Configure" }));
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    expect(screen.getByLabelText("Temperature")).toHaveValue(0.4);
    expect(presetSaveButton()).toBeDisabled();
  });

  it("allows the next switch click when a drag ends without a click event", async () => {
    const { payload } = settingsPayloadWithBackup();
    requestMutationMock
      .mockResolvedValueOnce({ ...payload, model_call_order: ["backup", "primary"] })
      .mockResolvedValueOnce({ ...payload, model_call_order: ["backup"] });
    renderSettingsView({ initialSection: "models", initialSettings: payload });
    const centers = mockPresetRowLayout();
    const backupRow = screen.getByTestId("model-call-order-row-backup");
    fireEvent.pointerDown(backupRow, { button: 0, clientY: centers[1], pointerId: 1 });
    fireEvent.pointerMove(backupRow, { clientY: centers[0], pointerId: 1, buttons: 1 });
    fireEvent.pointerUp(backupRow, { pointerId: 1 });
    await waitFor(() => expect(within(backupRow).getByText("Primary")).toBeInTheDocument());

    const toggle = within(screen.getByTestId("model-call-order-row-primary")).getByRole("switch");
    await waitFor(() => expect(toggle).toBeEnabled());
    fireEvent.pointerDown(toggle, { button: 0, pointerId: 1 });
    fireEvent.pointerUp(toggle, { pointerId: 1 });
    fireEvent.click(toggle);
    await waitFor(() => expect(requestMutationMock).toHaveBeenLastCalledWith(
      "settings.model_call_order.update", { order: ["backup"] }, 20_000,
    ));
  });

  it("restores the primary preview without saving when a pointer drag is cancelled", async () => {
    const { payload } = settingsPayloadWithBackup();
    renderSettingsView({ initialSection: "models", initialSettings: payload });
    const centers = mockPresetRowLayout();
    const backupRow = screen.getByTestId("model-call-order-row-backup");
    fireEvent.pointerDown(backupRow, { button: 0, clientY: centers[1], pointerId: 1 });
    fireEvent.pointerMove(backupRow, { clientY: centers[0] - 1, pointerId: 1, buttons: 1 });
    expect(within(backupRow).getByText("Primary")).toBeInTheDocument();
    fireEvent.pointerCancel(backupRow, { pointerId: 1 });
    expect(within(screen.getByTestId("model-call-order-row-primary")).getByText("Primary")).toBeInTheDocument();
    expect(requestMutationMock).not.toHaveBeenCalled();
  });

  it("keeps repeated fallback preset rows stable when changing the primary preset", async () => {
    const { payload, backupPreset } = settingsPayloadWithBackup();
    const initialPayload: SettingsPayload = {
      ...payload,
      agent: {
        ...payload.agent,
        model: backupPreset.model,
        provider: backupPreset.provider,
        resolved_provider: backupPreset.resolved_provider,
        model_preset: backupPreset.name,
      },
      model_presets: payload.model_presets.map((preset) => ({
        ...preset,
        active: preset.name === backupPreset.name,
      })),
      model_call_order: ["backup", "primary", "backup"],
    };
    const updatedPayload: SettingsPayload = {
      ...initialPayload,
      agent: {
        ...payload.agent,
        model_preset: "primary",
      },
      model_presets: payload.model_presets.map((preset) => ({
        ...preset,
        active: preset.name === "primary",
      })),
      model_call_order: ["primary", "backup", "backup"],
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return jsonResponse(initialPayload);
      if (url === "/api/settings/cli-apps") {
        return jsonResponse({ apps: [], installed_count: 0 });
      }
      if (url === "/api/settings/mcp-presets") {
        return jsonResponse({ presets: [], installed_count: 0 });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);
    requestMutationMock.mockResolvedValueOnce(updatedPayload);

    renderSettingsView({ initialSection: "models", initialSettings: initialPayload });

    const primaryRow = screen.getByTestId("model-call-order-row-primary");
    const backupRows = screen.getAllByTestId("model-call-order-row-backup");
    const secondBackupRow = backupRows[1];
    const secondBackupTrigger = within(secondBackupRow).getAllByRole("button")[0];
    fireEvent.click(secondBackupTrigger);
    expect(screen.getAllByTestId("model-preset-editor")).toHaveLength(1);
    expect(screen.getByRole("dialog", { name: "backup" })).toContainElement(screen.getByTestId("model-preset-editor"));
    expect(screen.getByRole("button", { name: "Delete" })).toBeDisabled();
    fireEvent.click(screen.getByRole("button", { name: "Close" }));

    const centers = mockPresetRowLayout();
    fireEvent.pointerDown(primaryRow, { button: 0, clientY: centers[1], pointerId: 1 });
    fireEvent.pointerMove(primaryRow, { clientY: centers[0], pointerId: 1, buttons: 1 });
    fireEvent.pointerUp(primaryRow, { pointerId: 1 });

    await waitFor(() =>
      expect(
        screen
          .getAllByTestId(/^model-call-order-row-/)
          .map((row) => row.getAttribute("data-testid")),
      ).toEqual([
        "model-call-order-row-primary",
        "model-call-order-row-backup",
        "model-call-order-row-backup",
      ]),
    );
  });

  it("restores the model call order when immediate persistence fails", async () => {
    const { payload } = settingsPayloadWithBackup();
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return jsonResponse(payload);
      if (url === "/api/settings/cli-apps") {
        return jsonResponse({ apps: [], installed_count: 0 });
      }
      if (url === "/api/settings/mcp-presets") {
        return jsonResponse({ presets: [], installed_count: 0 });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);
    requestMutationMock.mockRejectedValueOnce(new Error("Order update failed"));

    renderSettingsView({ initialSection: "models", initialSettings: payload });

    await waitFor(() =>
      expect(fetchMock).toHaveBeenCalledWith(
        "/api/settings",
        expect.objectContaining({
          headers: { Authorization: "Bearer tok" },
        }),
      ),
    );
    fireEvent.keyDown(screen.getByTestId("model-call-order-row-backup"), {
      key: "ArrowUp",
    });

    expect(await screen.findByText("Order update failed")).toBeInTheDocument();
    expect(
      screen
        .getAllByTestId(/^model-call-order-row-/)
        .map((row) => row.getAttribute("data-testid")),
    ).toEqual([
      "model-call-order-row-primary",
      "model-call-order-row-backup",
    ]);
  });

  it("shows presets outside the call order in the unified list and adds them directly", async () => {
    const { payload } = settingsPayloadWithBackup();
    const codexPreset = {
      ...payload.model_presets[0],
      name: "codex",
      label: "Codex",
      active: false,
      model: "openai-codex/gpt-5.5",
      provider: "openai",
      resolved_provider: "openai",
    };
    const payloadWithCodex: SettingsPayload = {
      ...payload,
      model_presets: [...payload.model_presets, codexPreset],
    };
    const orderedPayload: SettingsPayload = {
      ...payloadWithCodex,
      model_call_order: ["primary", "backup", "codex"],
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return jsonResponse(payloadWithCodex);
      if (url === "/api/settings/cli-apps") {
        return jsonResponse({ apps: [], installed_count: 0 });
      }
      if (url === "/api/settings/mcp-presets") {
        return jsonResponse({ presets: [], installed_count: 0 });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);
    requestMutationMock.mockResolvedValueOnce(orderedPayload);

    renderSettingsView({ initialSection: "models", initialSettings: payloadWithCodex });

    const codexRow = await screen.findByTestId("model-call-order-row-codex");
    expect(codexRow).toHaveTextContent("codex");
    expect(codexRow).toHaveAttribute("tabindex", "-1");

    const enableSwitch = within(codexRow).getByRole("switch", { name: "Enable preset" });
    expect(enableSwitch).not.toBeChecked();
    expect(enableSwitch).toHaveClass("h-5", "w-9", "bg-muted-foreground/25");
    fireEvent.click(enableSwitch);

    await waitFor(() => {
      expect(requestMutationMock).toHaveBeenCalledWith(
        "settings.model_call_order.update",
        { order: ["primary", "backup", "codex"] },
        20_000,
      );
    });
    const enabledCodexRow = await screen.findByTestId("model-call-order-row-codex");
    expect(enabledCodexRow).toHaveAttribute("tabindex", "0");
    expect(
      within(enabledCodexRow).getByRole("switch", { name: "Disable preset" }),
    ).toBeChecked();
    expect(within(enabledCodexRow).getByRole("switch")).toHaveClass("h-5", "w-9", "bg-foreground");
  });

  it("does not allow disabling the last preset", () => {
    renderSettingsView({ initialSection: "models", initialSettings: settingsPayload() });
    const toggle = screen.getByRole("switch", { name: "Disable preset" });
    expect(toggle).toBeChecked();
    expect(toggle).toBeDisabled();
    fireEvent.click(toggle);
    expect(requestMutationMock).not.toHaveBeenCalled();
  });

  it("appends a new model preset to the call order immediately", async () => {
    const { payload } = settingsPayloadWithBackup();
    const writerPreset = {
      ...payload.model_presets[0],
      name: "Writer",
      label: "Writer",
      active: false,
      model: "openai/gpt-4o-mini",
      provider: "openai",
      resolved_provider: "openai",
    };
    const createdPayload: SettingsPayload = {
      ...payload,
      model_presets: [...payload.model_presets, writerPreset],
      created_model_preset: writerPreset.name,
    };
    const orderedPayload: SettingsPayload = {
      ...createdPayload,
      model_call_order: ["primary", "backup", "Writer"],
      created_model_preset: undefined,
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return jsonResponse(payload);
      if (url === "/api/settings/cli-apps") {
        return jsonResponse({ apps: [], installed_count: 0 });
      }
      if (url === "/api/settings/mcp-presets") {
        return jsonResponse({ presets: [], installed_count: 0 });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);
    requestMutationMock
      .mockResolvedValueOnce(createdPayload)
      .mockResolvedValueOnce(orderedPayload);

    renderSettingsView({ initialSection: "models", initialSettings: payload });

    await waitFor(() =>
      expect(fetchMock).toHaveBeenCalledWith(
        "/api/settings",
        expect.objectContaining({
          headers: { Authorization: "Bearer tok" },
        }),
      ),
    );
    fireEvent.click(screen.getByRole("button", { name: "New preset" }));
    expect(screen.getByRole("dialog", { name: "New preset" })).toBeInTheDocument();
    expect(presetSaveButton()).toBeDisabled();
    fireEvent.change(screen.getByRole("textbox", { name: "Preset name" }), {
      target: { value: "Writer" },
    });
    const modelSearch = await openModelPicker();
    fireEvent.change(modelSearch, {
      target: { value: "openai/gpt-4o-mini" },
    });
    fireEvent.keyDown(modelSearch, { key: "Enter" });
    const saveButton = presetSaveButton();
    expect(saveButton).toBeEnabled();
    fireEvent.click(saveButton);

    await waitFor(() => {
      expect(requestMutationMock).toHaveBeenLastCalledWith(
        "settings.model_call_order.update",
        { order: ["primary", "backup", "Writer"] },
        20_000,
      );
    });
    const writerRow = await screen.findByTestId("model-call-order-row-Writer");
    fireEvent.click(screen.getByRole("button", { name: "Close" }));
    expect(within(writerRow).getByRole("switch", { name: "Disable preset" })).toBeChecked();
    expect(screen.getAllByText("Writer").length).toBeGreaterThan(0);
  });

  it("shows an inline error when a new preset name already exists", async () => {
    const { payload } = settingsPayloadWithBackup();
    vi.stubGlobal(
      "fetch",
      vi.fn(async () => ({ ok: false, status: 404, json: async () => ({}) }) as Response),
    );

    renderSettingsView({ initialSection: "models", initialSettings: payload });

    fireEvent.click(screen.getByRole("button", { name: "New preset" }));
    const nameInput = screen.getByRole("textbox", { name: "Preset name" });
    fireEvent.change(nameInput, { target: { value: "PRIMARY" } });
    const modelSearch = await openModelPicker();
    fireEvent.change(modelSearch, { target: { value: "openai/gpt-4o-mini" } });
    fireEvent.keyDown(modelSearch, { key: "Enter" });
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());

    expect(requestMutationMock).not.toHaveBeenCalled();
    expect(nameInput).toHaveAttribute("aria-invalid", "true");
    expect(nameInput).toHaveAttribute("aria-describedby", "model-preset-name-error");
    expect(screen.getByRole("alert")).toHaveTextContent(
      "A preset with this name already exists.",
    );
    expect(nameInput.parentElement).toHaveClass(
      "animate-[preset-name-shake_180ms_ease-in-out]",
    );

    fireEvent.change(nameInput, { target: { value: "Writer" } });
    expect(nameInput).toHaveAttribute("aria-invalid", "false");
  });

  it("converts legacy model settings into presets before editing call order", async () => {
    const migratedPayload = settingsPayload();
    const defaultPreset = {
      ...migratedPayload.model_presets[0],
      name: "default",
      label: "Default",
      is_default: true,
    };
    const legacyPayload: SettingsPayload = {
      ...migratedPayload,
      agent: {
        ...migratedPayload.agent,
        model_preset: "default",
      },
      model_presets: [defaultPreset],
      model_call_order: [],
      model_call_order_editable: false,
      model_configuration_migratable: true,
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return jsonResponse(legacyPayload);
      if (url === "/api/settings/cli-apps") {
        return jsonResponse({ apps: [], installed_count: 0 });
      }
      if (url === "/api/settings/mcp-presets") {
        return jsonResponse({ presets: [], installed_count: 0 });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);
    requestMutationMock.mockResolvedValueOnce(migratedPayload);

    renderSettingsView({ initialSection: "models", initialSettings: legacyPayload });

    fireEvent.click(
      await screen.findByRole("button", { name: "Convert to presets" }),
    );

    await waitFor(() =>
      expect(requestMutationMock).toHaveBeenCalledWith(
        "settings.model_configuration.migrate",
        {},
        20_000,
      ),
    );
  });

  it("starts fresh users with an empty preset list instead of legacy conversion", async () => {
    const base = settingsPayload();
    const freshPayload: SettingsPayload = {
      ...base,
      agent: {
        ...base.agent,
        model: "anthropic/claude-opus-4-5",
        provider: "auto",
        resolved_provider: null,
        has_api_key: false,
        model_preset: "default",
      },
      model_presets: [
        {
          ...base.model_presets[0],
          name: "default",
          label: "Default",
          active: true,
          is_default: true,
          model: "anthropic/claude-opus-4-5",
          provider: "auto",
          resolved_provider: null,
        },
      ],
      model_call_order: [],
      model_call_order_editable: false,
      model_configuration_migratable: false,
      providers: [],
    };
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));

    renderSettingsView({ initialSection: "models", initialSettings: freshPayload });

    expect(
      await screen.findByRole("button", { name: "New preset" }),
    ).toBeInTheDocument();
  });

  it("does not expose the synthetic default configuration as a WebUI preset", async () => {
    const base = settingsPayload();
    const payload: SettingsPayload = {
      ...base,
      agent: {
        ...base.agent,
        model: "MiniMax-M3",
        provider: "minimax_anthropic",
        resolved_provider: "minimax_anthropic",
        model_preset: "fast",
      },
      model_presets: [
        {
          ...base.model_presets[0],
          name: "default",
          label: "Default",
          active: false,
          is_default: true,
          model: "openai-codex/gpt-5.5",
          provider: "openai_codex",
          resolved_provider: "openai_codex",
        },
        {
          ...base.model_presets[0],
          name: "fast",
          label: "fast",
          active: true,
          is_default: false,
          model: "MiniMax-M3",
          provider: "minimax_anthropic",
          resolved_provider: "minimax_anthropic",
        },
      ],
      model_call_order: ["fast"],
      providers: [
        {
          name: "openai_codex",
          label: "OpenAI Codex",
          configured: true,
          auth_type: "oauth",
          api_key_required: false,
          api_key_hint: null,
          api_base: null,
          default_api_base: null,
          oauth_account: "acct-test",
          oauth_expires_at: null,
          oauth_login_supported: true,
        },
        {
          name: "minimax_anthropic",
          label: "MiniMax (Anthropic)",
          configured: true,
          auth_type: "api_key",
          api_key_required: true,
          api_key_hint: "sk-...",
          api_base: "https://api.minimax.io/anthropic",
          default_api_base: "https://api.minimax.io/anthropic",
        },
      ],
    };
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));

    renderSettingsView({ initialSection: "models", initialSettings: payload });

    expect(screen.getAllByText("fast").length).toBeGreaterThan(0);
  });

  it("does not expose the synthetic default preset in the overview summary", async () => {
    const base = settingsPayload();
    const payload: SettingsPayload = {
      ...base,
      agent: {
        ...base.agent,
        model_preset: "default",
      },
      model_presets: [
        {
          ...base.model_presets[0],
          name: "default",
          label: "Default",
          is_default: true,
        },
      ],
      model_call_order: [],
      model_call_order_editable: false,
      providers: [{
        name: "openai", label: "openai", configured: true,
        api_key_required: true, api_key_hint: "sk-...",
      }],
    };
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));

    renderSettingsView({ initialSection: "overview", initialSettings: payload });

    expect(await screen.findByText("openai/gpt-4o")).toBeInTheDocument();
    expect(screen.getByText("openai")).toBeInTheDocument();
  });

  it("uses the resolved provider row for auto dynamic providers without api keys", async () => {
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));

    renderSettingsView({
      initialSection: "models",
      initialSettings: autoDynamicProviderPayload({
        configured: true,
        hasApiKey: false,
        apiBase: "https://proxy.example.test/v1",
        apiKeyHint: null,
      }),
    });

    expect(screen.queryByText("Provider setup required")).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Manage providers" }));
    expect(screen.getByRole("button", { name: "Company Proxy" })).toBeInTheDocument();
  });

  it("does not treat auto dynamic provider api keys as configured without apiBase", async () => {
    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));

    renderSettingsView({
      initialSection: "models",
      initialSettings: autoDynamicProviderPayload({
        configured: false,
        hasApiKey: true,
        apiBase: null,
        apiKeyHint: "sk-...",
      }),
    });

    expect(screen.getByText("Provider setup required")).toBeInTheDocument();
  });

  it("marks the current model as unconfigured when its provider needs setup", async () => {
    const payload: SettingsPayload = {
      ...settingsPayload(),
      agent: {
        ...settingsPayload().agent,
        model: "openai-codex/gpt-5.1-codex",
        provider: "openai_codex",
        resolved_provider: "openai_codex",
        has_api_key: false,
      },
      model_presets: [
        {
          ...settingsPayload().model_presets[0],
          model: "openai-codex/gpt-5.1-codex",
          provider: "openai_codex",
        },
      ],
      providers: [
        {
          name: "openai_codex",
          label: "OpenAI Codex",
          configured: false,
          auth_type: "oauth",
          api_key_required: false,
          api_key_hint: null,
          api_base: null,
          default_api_base: null,
          oauth_account: null,
          oauth_expires_at: null,
          oauth_login_supported: true,
        },
      ],
    };
    vi.stubGlobal(
      "fetch",
      vi.fn(async (input: RequestInfo | URL) => {
        const url = String(input);
        if (url === "/api/settings") return jsonResponse(payload);
        if (url === "/api/settings/cli-apps") {
          return jsonResponse({ apps: [], installed_count: 0 });
        }
        if (url === "/api/settings/mcp-presets") {
          return jsonResponse({ presets: [], installed_count: 0 });
        }
        return { ok: false, status: 404, json: async () => ({}) } as Response;
      }),
    );

    renderSettingsView({ initialSection: "models" });

    expect(await screen.findByText("Provider setup required")).toBeInTheDocument();
    await togglePresetEditor();
    fireEvent.click(screen.getByRole("button", { name: "Sign in required" }));
    expect(await screen.findByRole("tooltip")).toHaveTextContent(/Sign in before saving/);
    expect(await screen.findByRole("button", { name: "Sign in" })).toBeInTheDocument();
  });

  it("keeps unsigned OAuth providers out of the active provider picker", async () => {
    const payload: SettingsPayload = {
      ...settingsPayload(),
      agent: {
        ...settingsPayload().agent,
        model: "deepseek-chat",
        provider: "deepseek",
        resolved_provider: "deepseek",
      },
      model_presets: [
        {
          ...settingsPayload().model_presets[0],
          model: "deepseek-chat",
          provider: "deepseek",
        },
      ],
      providers: [
        {
          name: "deepseek",
          label: "DeepSeek",
          configured: true,
          auth_type: "api_key",
          api_key_required: true,
          api_key_hint: "sk-...",
          api_base: "https://api.deepseek.com",
          default_api_base: "https://api.deepseek.com",
        },
        {
          name: "openai_codex",
          label: "OpenAI Codex",
          configured: false,
          auth_type: "oauth",
          api_key_required: false,
          api_key_hint: null,
          api_base: null,
          default_api_base: null,
          oauth_account: null,
          oauth_expires_at: null,
          oauth_login_supported: true,
        },
        {
          name: "github_copilot",
          label: "GitHub Copilot",
          configured: false,
          auth_type: "oauth",
          api_key_required: false,
          api_key_hint: null,
          api_base: null,
          default_api_base: "https://api.githubcopilot.com",
          oauth_account: null,
          oauth_expires_at: null,
          oauth_login_supported: true,
        },
      ],
    };
    vi.stubGlobal(
      "fetch",
      vi.fn(async (input: RequestInfo | URL) => {
        const url = String(input);
        if (url === "/api/settings") return jsonResponse(payload);
        if (url === "/api/settings/cli-apps") {
          return jsonResponse({ apps: [], installed_count: 0 });
        }
        if (url === "/api/settings/mcp-presets") {
          return jsonResponse({ presets: [], installed_count: 0 });
        }
        return { ok: false, status: 404, json: async () => ({}) } as Response;
      }),
    );

    renderSettingsView({ initialSection: "models" });

    await togglePresetEditor();
    const providerPicker = await screen.findByRole("combobox", { name: /DeepSeek/ });
    fireEvent.keyDown(providerPicker, { key: "ArrowDown" });

    expect(await screen.findByRole("option", { name: "DeepSeek" })).toBeInTheDocument();
    expect(screen.queryByRole("option", { name: "OpenAI Codex" })).not.toBeInTheDocument();
    expect(screen.queryByRole("option", { name: "GitHub Copilot" })).not.toBeInTheDocument();
  });

  it("does not fetch model lists for unsigned OAuth providers", async () => {
    const payload: SettingsPayload = {
      ...settingsPayload(),
      agent: {
        ...settingsPayload().agent,
        model: "",
        provider: "openai_codex",
        resolved_provider: "openai_codex",
      },
      model_presets: [
        {
          ...settingsPayload().model_presets[0],
          model: "",
          provider: "openai_codex",
        },
      ],
      providers: [
        {
          name: "openai_codex",
          label: "OpenAI Codex",
          configured: false,
          auth_type: "oauth",
          api_key_required: false,
          api_key_hint: null,
          api_base: null,
          default_api_base: null,
          oauth_account: null,
          oauth_expires_at: null,
          oauth_login_supported: true,
        },
        {
          name: "github_copilot",
          label: "GitHub Copilot",
          configured: false,
          auth_type: "oauth",
          api_key_required: false,
          api_key_hint: null,
          api_base: null,
          default_api_base: "https://api.githubcopilot.com",
          oauth_account: null,
          oauth_expires_at: null,
          oauth_login_supported: true,
        },
      ],
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return jsonResponse(payload);
      if (url === "/api/settings/cli-apps") {
        return jsonResponse({ apps: [], installed_count: 0 });
      }
      if (url === "/api/settings/mcp-presets") {
        return jsonResponse({ presets: [], installed_count: 0 });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);

    renderSettingsView({ initialSection: "models" });

    await togglePresetEditor();
    await openModelPicker();
    expect(
      await screen.findByText("Configure this provider before loading models."),
    ).toBeInTheDocument();
    expect(
      fetchMock.mock.calls.some(([input]) =>
        String(input).startsWith("/api/settings/provider-models"),
      ),
    ).toBe(false);
  });

  it("prefills manual model ids for configured OAuth providers", async () => {
    const payload: SettingsPayload = {
      ...settingsPayload(),
      agent: {
        ...settingsPayload().agent,
        model: "open-codex/gpt-5.5",
        provider: "openai_codex",
        resolved_provider: "openai_codex",
      },
      model_presets: [
        {
          ...settingsPayload().model_presets[0],
          model: "open-codex/gpt-5.5",
          provider: "openai_codex",
        },
      ],
      providers: [
        {
          name: "openai_codex",
          label: "OpenAI Codex",
          configured: true,
          auth_type: "oauth",
          api_key_required: false,
          api_key_hint: null,
          api_base: null,
          default_api_base: null,
          oauth_account: "acct-test",
          oauth_expires_at: null,
          oauth_login_supported: true,
        },
      ],
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return jsonResponse(payload);
      if (url === "/api/settings/cli-apps") {
        return jsonResponse({ apps: [], installed_count: 0 });
      }
      if (url === "/api/settings/mcp-presets") {
        return jsonResponse({ presets: [], installed_count: 0 });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);

    renderSettingsView({ initialSection: "models" });

    await togglePresetEditor();
    const input = await openModelPicker();
    expect(input).toHaveValue("open-codex/gpt-5.5");

    fireEvent.change(input, { target: { value: "openai-codex/gpt-5.5" } });
    expect(await screen.findByText("“openai-codex/gpt-5.5”")).toBeInTheDocument();
    expect(
      fetchMock.mock.calls.some(([input]) =>
        String(input).startsWith("/api/settings/provider-models"),
      ),
    ).toBe(false);
  });

  it("defers the OrcaRouter catalog until the user searches", async () => {
    const base = settingsPayload();
    const payload: SettingsPayload = {
      ...base,
      agent: {
        ...base.agent,
        model: "orcarouter/auto",
        provider: "orcarouter",
        resolved_provider: "orcarouter",
      },
      model_presets: [
        {
          ...base.model_presets[0],
          model: "orcarouter/auto",
          provider: "orcarouter",
          resolved_provider: "orcarouter",
        },
      ],
      providers: [
        {
          name: "orcarouter",
          label: "OrcaRouter",
          configured: true,
          auth_type: "api_key",
          api_key_required: true,
          api_key_hint: "sk-o••••test",
          api_base: null,
          default_api_base: "https://api.orcarouter.ai/v1",
          model_catalog: "catalog",
        },
      ],
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return jsonResponse(payload);
      if (url === "/api/settings/cli-apps") {
        return jsonResponse({ apps: [], installed_count: 0 });
      }
      if (url === "/api/settings/mcp-presets") {
        return jsonResponse({ presets: [], installed_count: 0 });
      }
      if (url === "/api/settings/provider-models?provider=orcarouter") {
        return jsonResponse({
          provider: "orcarouter",
          label: "OrcaRouter",
          status: "available",
          catalog_kind: "catalog",
          models: [
            { id: "orcarouter/auto", owned_by: "orcarouter" },
            { id: "anthropic/claude-sonnet-4.6", owned_by: "anthropic" },
          ],
          model_count: 2,
          fetched_at: 1,
        });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);

    renderSettingsView({ initialSection: "models" });

    await togglePresetEditor();
    await openModelPicker();
    expect(await screen.findByText("Search this provider’s model catalog.")).toBeInTheDocument();
    expect(
      fetchMock.mock.calls.some(([input]) =>
        String(input).startsWith("/api/settings/provider-models"),
      ),
    ).toBe(false);

    fireEvent.change(screen.getByPlaceholderText("Choose model"), {
      target: { value: "cl" },
    });

    await screen.findByText("anthropic/claude-sonnet-4.6");
    expect(fetchMock).toHaveBeenCalledWith(
      "/api/settings/provider-models?provider=orcarouter",
      expect.objectContaining({
        headers: { Authorization: "Bearer tok" },
      }),
    );
  });

  it("loads curated models for configured OAuth providers", async () => {
    const base = settingsPayload();
    const payload: SettingsPayload = {
      ...base,
      agent: {
        ...base.agent,
        model: "openai-codex/gpt-5.5",
        provider: "openai_codex",
        resolved_provider: "openai_codex",
      },
      model_presets: [
        {
          ...base.model_presets[0],
          model: "openai-codex/gpt-5.5",
          provider: "openai_codex",
        },
      ],
      providers: [
        {
          name: "openai_codex",
          label: "OpenAI Codex",
          configured: true,
          auth_type: "oauth",
          api_key_required: false,
          api_key_hint: null,
          api_base: null,
          default_api_base: "https://chatgpt.com/backend-api",
          model_catalog: "builtin",
          oauth_account: "acct-test",
          oauth_expires_at: null,
          oauth_login_supported: true,
        },
      ],
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings/provider-models?provider=openai_codex") {
        return jsonResponse({
          provider: "openai_codex",
          label: "OpenAI Codex",
          status: "available",
          catalog_kind: "builtin",
          models: [
            {
              id: "openai-codex/gpt-5.6-sol",
              label: "GPT-5.6-Sol",
              description: "Latest frontier agentic coding model.",
              owned_by: "OpenAI Codex",
              context_window: 372000,
            },
          ],
          model_count: 1,
          fetched_at: 1,
        });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);

    renderSettingsView({ initialSection: "models", initialSettings: payload });

    await togglePresetEditor();
    await openModelPicker();

    expect(await screen.findByText("GPT-5.6-Sol")).toBeInTheDocument();
    expect(screen.getByText(/Latest frontier agentic coding model\./)).toBeInTheDocument();
    expect(fetchMock).toHaveBeenCalledWith(
      "/api/settings/provider-models?provider=openai_codex",
      expect.objectContaining({ headers: { Authorization: "Bearer tok" } }),
    );
  });

  it("loads hybrid online models for configured OAuth providers", async () => {
    const base = settingsPayload();
    const payload: SettingsPayload = {
      ...base,
      agent: {
        ...base.agent,
        model: "xai-grok/grok-4.5",
        provider: "xai_grok",
        resolved_provider: "xai_grok",
      },
      model_presets: [
        {
          ...base.model_presets[0],
          model: "xai-grok/grok-4.5",
          provider: "xai_grok",
        },
      ],
      providers: [
        {
          name: "xai_grok",
          label: "xAI Grok",
          configured: true,
          auth_type: "oauth",
          api_key_required: false,
          api_key_hint: null,
          api_base: null,
          default_api_base: "https://cli-chat-proxy.grok.com/v1",
          model_catalog: "hybrid",
          oauth_account: "acct-test",
          oauth_expires_at: null,
          oauth_login_supported: true,
        },
      ],
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings/provider-models?provider=xai_grok") {
        return jsonResponse({
          provider: "xai_grok",
          label: "xAI Grok",
          status: "available",
          catalog_kind: "hybrid",
          source: "remote",
          models: [
            {
              id: "xai-grok/grok-4.6",
              label: "Grok 4.6",
              description: "Latest frontier model",
              owned_by: "xAI",
              context_window: 500_000,
            },
            {
              id: "xai-grok/grok-4.5",
              label: "Grok 4.5",
              owned_by: "xAI",
              context_window: 500_000,
            },
          ],
          model_count: 2,
          fetched_at: 1,
        });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);

    renderSettingsView({ initialSection: "models", initialSettings: payload });

    await togglePresetEditor();
    const modelInput = await openModelPicker();

    expect(await screen.findByText("Grok 4.6")).toBeInTheDocument();
    expect(screen.getByText(/Latest frontier model/)).toBeInTheDocument();
    expect(fetchMock).toHaveBeenCalledWith(
      "/api/settings/provider-models?provider=xai_grok",
      expect.objectContaining({ headers: { Authorization: "Bearer tok" } }),
    );
    fireEvent.keyDown(document.activeElement!, { key: "Escape" });
    await waitFor(() => expect(modelInput).toHaveFocus());
    fireEvent.click(screen.getByRole("button", { name: "Close" }));
    await waitFor(() => expect(within(screen.getByTestId("model-call-order-row-primary")).getAllByRole("button")[0]).toBeVisible());
  });

  it("creates presets in a dialog and can cancel", async () => {
    const payload = settingsPayload();
    payload.providers = [{ name: "openai", label: "OpenAI", configured: true }];
    vi.stubGlobal(
      "fetch",
      vi.fn(async (input: RequestInfo | URL) => {
        const url = String(input);
        if (url === "/api/settings") return jsonResponse(payload);
        if (url === "/api/settings/cli-apps") {
          return jsonResponse({ apps: [], installed_count: 0 });
        }
        if (url === "/api/settings/mcp-presets") {
          return jsonResponse({ presets: [], installed_count: 0 });
        }
        return { ok: false, status: 404, json: async () => ({}) } as Response;
      }),
    );

    renderSettingsView({ initialSection: "models" });

    const createButton = await screen.findByRole("button", { name: "New preset" });
    const previousPointerEvents = document.body.style.pointerEvents;
    fireEvent.click(createButton);

    expect(screen.getByRole("dialog", { name: "New preset" })).toBeInTheDocument();
    expect(screen.getByRole("dialog")).toContainElement(screen.getByTestId("model-preset-editor"));
    expect(screen.getByRole("textbox", { name: "Preset name" })).toHaveValue("");
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    expect(screen.getByText("Temperature")).toBeInTheDocument();
    await returnToPresetEditor();
    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));

    await waitFor(() => expect(document.body.style.pointerEvents).toBe(previousPointerEvents));
    await waitFor(() => expect(createButton).toHaveFocus());

    fireEvent.click(screen.getByRole("button", { name: "New preset" }));
    const nameInput = await screen.findByRole("textbox", { name: "Preset name" });
    expect(nameInput).toHaveValue("");
    expect(nameInput).toHaveAttribute("placeholder", "e.g. Fast writing");

    const modelSearch = await openModelPicker();
    fireEvent.change(modelSearch, { target: { value: "openai/gpt-4o-mini" } });
    fireEvent.keyDown(modelSearch, { key: "Enter" });

    expect(nameInput).toHaveValue("gpt-4o-mini");
    expect(presetSaveButton()).toBeEnabled();

    fireEvent.change(nameInput, { target: { value: "Writer" } });
    const nextModelSearch = await openModelPicker();
    fireEvent.change(nextModelSearch, { target: { value: "openai/gpt-4.1-mini" } });
    fireEvent.keyDown(nextModelSearch, { key: "Enter" });
    expect(nameInput).toHaveValue("Writer");
  });

  it.each([
    { context: 1_000_000, manual: undefined, expected: "1m" },
    { context: 1_000_000, manual: "256k", expected: "256k" },
    { context: null, manual: undefined, expected: "200k" },
  ])("initializes new preset context from the selected model while preserving overrides ($expected)", async ({ context, manual, expected }) => {
    const payload = settingsPayload();
    payload.model_presets[0].provider = "openai";
    payload.model_presets[0].context_window_tokens = 200_000;
    payload.providers = [{ name: "openai", label: "OpenAI", configured: true }];
    vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return new Promise<Response>(() => {});
      if (url.includes("/provider-models?")) return jsonResponse({
        provider: "openai", status: "available", catalog_kind: "official",
        models: [{ id: "catalog-model", context_window: context, reasoning_efforts: ["low", "high"] }], model_count: 1,
      });
      return jsonResponse(payload);
    }));
    requestMutationMock.mockResolvedValue(payload);
    renderSettingsView({ initialSection: "models", initialSettings: payload });
    fireEvent.click(screen.getByRole("button", { name: "New preset" }));
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    if (manual) fireEvent.change(screen.getByRole("textbox", { name: "Context window" }), { target: { value: manual } });
    await returnToPresetEditor();
    await openModelPicker();
    fireEvent.click(await screen.findByRole("option", { name: /catalog-model/ }));
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    await waitFor(() => expect(screen.getByRole("textbox", { name: "Context window" })).toHaveValue(expected));
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
      "settings.model_configuration.create", expect.objectContaining({ context_window_tokens: manual ? 256000 : context ?? 200000 }), expect.any(Number),
    ));
  });

  it("offers catalog reasoning levels including max and none, distinct from Default, and retains manual values", async () => {
    const payload = settingsPayload();
    payload.model_presets[0].provider = "deepseek";
    payload.model_presets[0].resolved_provider = "deepseek";
    payload.model_presets[0].model = "deepseek-flash";
    payload.model_presets[0].reasoning_effort = "high";
    payload.model_presets[0].reasoning_effort_values = ["", "low", "medium", "high"];
    payload.providers = [{ name: "deepseek", label: "DeepSeek", configured: true }];
    const catalog: ProviderModelsPayload = {
      provider: "deepseek", label: "DeepSeek", status: "available", catalog_kind: "official",
      models: [
        {
          id: payload.model_presets[0].model, max_output_tokens: 393_216,
          input_modalities: ["text", "image"], output_modalities: ["text"],
          reasoning_efforts: ["none", "low", "high", "max"], default_reasoning_effort: "high",
        },
        { id: "another-model", reasoning_efforts: ["ultra"] },
      ], model_count: 2,
    };
    vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => String(input).includes("/provider-models?")
      ? jsonResponse(catalog) : jsonResponse(payload)));
    requestMutationMock.mockResolvedValue(payload);
    renderSettingsView({ initialSection: "models", initialSettings: payload });
    await togglePresetEditor();
    const input = screen.getByRole("combobox", { name: "Reasoning effort" });
    fireEvent.click(input);
    fireEvent.click(await screen.findByRole("option", { name: "max" }));
    await waitFor(() => expect(input).toHaveValue("max"));
    fireEvent.click(input);
    expect(screen.queryByRole("option", { name: "ultra" })).not.toBeInTheDocument();
    expect(screen.queryByRole("option", { name: "medium" })).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("option", { name: "none" }));
    await waitFor(() => expect(input).toHaveValue("none"));
    fireEvent.click(input);
    fireEvent.click(screen.getByRole("option", { name: "Default" }));
    await waitFor(() => expect(input).toHaveValue(""));
    fireEvent.click(input);
    fireEvent.change(input, { target: { value: "provider-native-mode" } });
    fireEvent.keyDown(input, { key: "Enter" });
    await returnToPresetEditor();
    fireEvent.click(presetSaveButton());
    await waitFor(() => expect(requestMutationMock).toHaveBeenCalledWith(
      "settings.model_configuration.update", expect.objectContaining({ reasoning_effort: "provider-native-mode" }), expect.any(Number),
    ));
  });

  it("loads provider models and lets users choose one without typing the id manually", async () => {
    const payload: SettingsPayload = {
      ...settingsPayload(),
      agent: {
        ...settingsPayload().agent,
        model: "deepseek-chat",
        provider: "deepseek",
        resolved_provider: "deepseek",
      },
      model_presets: [
        {
          ...settingsPayload().model_presets[0],
          model: "deepseek-chat",
          provider: "deepseek",
        },
      ],
      providers: [
        {
          name: "deepseek",
          label: "DeepSeek",
          configured: true,
          auth_type: "api_key",
          api_key_required: true,
          api_key_hint: "sk-...",
          api_base: "https://api.deepseek.com",
          default_api_base: "https://api.deepseek.com",
        },
      ],
    };
    const updatedPayload: SettingsPayload = {
      ...payload,
      agent: {
        ...payload.agent,
        model: "deepseek-reasoner",
        temperature: 0.4,
      },
      model_presets: [
        {
        ...payload.model_presets[0],
        model: "deepseek-reasoner",
        temperature: 0.4,
        reasoning_effort: "provider-native-mode",
      },
      ],
    };
    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
      const url = String(input);
      if (url === "/api/settings") return jsonResponse(payload);
      if (url === "/api/settings/cli-apps") {
        return jsonResponse({ apps: [], installed_count: 0 });
      }
      if (url === "/api/settings/mcp-presets") {
        return jsonResponse({ presets: [], installed_count: 0 });
      }
      if (url === "/api/settings/provider-models?provider=deepseek") {
        return jsonResponse({
          provider: "deepseek",
          label: "DeepSeek",
          status: "available",
          catalog_kind: "official",
          models: [
            { id: "deepseek-chat", owned_by: "deepseek", context_window: 65536 },
            { id: "deepseek-reasoner", owned_by: "deepseek", context_window: 65536 },
          ],
          model_count: 2,
          fetched_at: 1,
        });
      }
      return { ok: false, status: 404, json: async () => ({}) } as Response;
    });
    vi.stubGlobal("fetch", fetchMock);
    requestMutationMock.mockResolvedValueOnce(updatedPayload);

    renderSettingsView({ initialSection: "models" });

    await togglePresetEditor();
    await openModelPicker();
    await screen.findByText("deepseek-reasoner");
    fireEvent.click(screen.getAllByText("deepseek-reasoner")[0]);
    fireEvent.click(screen.getByRole("button", { name: /Advanced options/ }));
    fireEvent.change(screen.getByLabelText("Temperature"), {
      target: { value: "0.4" },
    });
    await returnToPresetEditor();
    fireEvent.change(screen.getByLabelText("Reasoning effort"), {
      target: { value: "provider-native-mode" },
    });
    fireEvent.blur(screen.getByLabelText("Reasoning effort"));

    await waitFor(() =>
      expect(fetchMock).toHaveBeenCalledWith(
        "/api/settings/provider-models?provider=deepseek",
        expect.objectContaining({
          headers: { Authorization: "Bearer tok" },
        }),
      ),
    );
    await waitFor(() => {
      const saveCall = requestMutationMock.mock.calls.find(([action]) =>
        action === "settings.model_configuration.update",
      );
      expect(saveCall).toBeDefined();
      expect(saveCall?.[1]).toEqual({ name: "primary", model: "deepseek-reasoner" });
      expect(requestMutationMock).toHaveBeenCalledWith(
        "settings.model_configuration.update", expect.objectContaining({ reasoning_effort: "provider-native-mode" }), 20_000,
      );
    });
  });
});