Skip to content

armgit / mso

Public Imported from GitHub
0

Browser-based graphical shell and control plane for a Linux server you own — real terminal, file manager, live metrics and BYOK AI in one mobile-first workspace. Next.js 16 · React 19 · node-pty · Tailwind v4 · shadcn/ui. Public alpha, self-hosted.

fix(settings): bounded provider picker, auto-discovery, honest model switching (#151)

Abdurrahman Fakhrul8b1c19695fad
diff --git a/frontend/slices/assistant/components/model-quick-control.test.tsx b/frontend/slices/assistant/components/model-quick-control.test.tsx
new file mode 100644
index 00000000..5181d965
--- /dev/null
+++ b/frontend/slices/assistant/components/model-quick-control.test.tsx
@@ -0,0 +1,104 @@
+import { describe, expect, it, vi } from "vitest";
+import { renderToStaticMarkup } from "react-dom/server";
+import type { ReactNode } from "react";
+import {
+ ModelPickerBody,
+ isStaleSelection,
+ modelOptionText,
+ modelOptions,
+ modelsFromResponse,
+ type ModelLoad,
+} from "./model-quick-control";
+
+// Radix portals do not render server-side and SelectItem needs Select context, so
+// the primitive is a plain element here. These tests assert the three-state model
+// picker markup, which is where complaint 3 lives.
+vi.mock("@/components/ui/select", () => ({
+ Select: ({ children }: { children: ReactNode }) => <div data-slot="select">{children}</div>,
+ SelectTrigger: ({ children, ...props }: { children: ReactNode } & Record<string, unknown>) => (
+ <div data-slot="select-trigger" {...props}>{children}</div>
+ ),
+ SelectValue: ({ placeholder }: { placeholder?: string }) => <span data-slot="select-value">{placeholder ?? ""}</span>,
+ SelectContent: ({ children, className }: { children: ReactNode; className?: string }) => (
+ <div data-slot="select-content" className={className}>{children}</div>
+ ),
+ SelectGroup: ({ children }: { children: ReactNode }) => <div data-slot="select-group">{children}</div>,
+ SelectItem: ({ children }: { children: ReactNode }) => <div data-slot="select-item">{children}</div>,
+ SelectLabel: ({ children }: { children: ReactNode }) => <div data-slot="select-label">{children}</div>,
+}));
+
+const noop = () => {};
+const rows = [{ id: "gpt-4o", name: "GPT-4o" }, { id: "o3", name: "o3" }];
+
+function picker(load: ModelLoad, modelRows = rows, activeModel = "gpt-4o") {
+ return renderToStaticMarkup(
+ <ModelPickerBody
+ load={load} rows={modelRows} activeModel={activeModel} provider="ai-hub"
+ saving={false} discovering={false} onReload={noop} onDiscover={noop} onSelect={noop}
+ />,
+ );
+}
+
+describe("model picker states", () => {
+ it("renders an error with a retry — never an empty list — when the fetch fails", () => {
+ const html = picker({ state: "error", error: "HTTP 500" });
+ expect(html).toContain('role="alert"');
+ expect(html).toContain("Couldn’t load");
+ expect(html).toContain("HTTP 500");
+ expect(html).toContain("Retry");
+ expect(html).not.toContain("reports no models");
+ expect(html).not.toContain("select-item");
+ });
+
+ it("renders an explicit empty state with a Discover affordance for a provider with zero models", () => {
+ const html = picker({ state: "ok" }, []);
+ expect(html).toContain("reports no models");
+ expect(html).toContain("Discover");
+ expect(html).not.toContain("select-item");
+ expect(html).not.toContain('role="alert"');
+ });
+
+ it("renders the real catalog, marking the selection that is current", () => {
+ const html = picker({ state: "ok" });
+ expect(html).toContain("GPT-4o (current)");
+ expect(html).toContain("o3");
+ expect(html).not.toContain("Retry");
+ expect(html).not.toContain("reports no models");
+ });
+
+ it("shows a loading placeholder rather than an empty list while fetching", () => {
+ const html = picker({ state: "loading" });
+ expect(html).toContain("Loading models…");
+ expect(html).not.toContain("reports no models");
+ });
+});
+
+describe("model switch honesty", () => {
+ it("distinguishes a failed fetch from an empty provider", () => {
+ expect(modelsFromResponse(500, {})).toEqual({ load: { state: "error", error: "HTTP 500" }, rows: [] });
+ expect(modelsFromResponse(401, {})).toEqual({ load: { state: "error", error: "HTTP 401" }, rows: [] });
+ expect(modelsFromResponse(200, { models: [] })).toEqual({ load: { state: "ok" }, rows: [] });
+ expect(modelsFromResponse(200, { models: rows })).toEqual({ load: { state: "ok" }, rows });
+ expect(modelsFromResponse(200, {})).toEqual({ load: { state: "ok" }, rows: [] });
+ });
+
+ it("keeps the saved model selectable when a refresh drops it", () => {
+ expect(modelOptions(rows, "gpt-4o")).toBe(rows);
+ expect(modelOptions(rows, "gone").map((row) => row.id)).toEqual(["gone", "gpt-4o", "o3"]);
+ expect(modelOptions([], "gone").map((row) => row.id)).toEqual(["gone"]);
+ });
+
+ it("reports a stale selection instead of silently picking another model", () => {
+ expect(isStaleSelection({ state: "ok" }, rows, "gone")).toBe(true);
+ expect(isStaleSelection({ state: "ok" }, rows, "gpt-4o")).toBe(false);
+ expect(isStaleSelection({ state: "error" }, rows, "gone")).toBe(false);
+ expect(isStaleSelection({ state: "ok" }, [], "gone")).toBe(false);
+ expect(isStaleSelection({ state: "ok" }, rows, "")).toBe(false);
+ });
+
+ it("marks only the selected row as current", () => {
+ expect(modelOptionText(rows[0], "gpt-4o")).toBe("GPT-4o (current)");
+ expect(modelOptionText(rows[1], "gpt-4o")).toBe("o3");
+ expect(modelOptionText({ id: "raw-id" }, "raw-id")).toBe("raw-id (current)");
+ });
+});
diff --git a/frontend/slices/assistant/components/model-quick-control.tsx b/frontend/slices/assistant/components/model-quick-control.tsx
index 37732ee8..b755d4a5 100644
--- a/frontend/slices/assistant/components/model-quick-control.tsx
+++ b/frontend/slices/assistant/components/model-quick-control.tsx
@@ -3,24 +3,97 @@
import { useEffect, useMemo, useState } from "react";
import { CheckCircle2, Loader2, TriangleAlert } from "lucide-react";
import { Button } from "@/components/ui/button";
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Select, SelectTrigger, SelectValue } from "@/components/ui/select";
+// Relative (not `@/features/...`) because os-settings exports no component barrel
+// and deep `@/features/*/components/*` imports warn under no-restricted-imports.
+import { ProviderSelectContent } from "../../os-settings/components/provider-filter-list";
import {
- quickModelForProvider,
- quickProviderIds,
- quickProviderLabel,
- type QuickCatalogModel,
- type QuickConnectedProvider,
+ quickModelForProvider, quickProviderIds, quickProviderLabel,
+ type QuickCatalogModel, type QuickConnectedProvider,
} from "./model-quick-options";
type ConfigSnapshot = { providers?: QuickConnectedProvider[] };
+export type ModelLoad = { state: "loading" | "ok" | "error"; error?: string };
+/** The saved model stays selectable even when the catalog omits it, so a refresh
+ * never silently rewrites the user's choice. */
+export function modelOptions(rows: QuickCatalogModel[], activeModel: string): QuickCatalogModel[] {
+ return !activeModel || rows.some((row) => row.id === activeModel)
+ ? rows
+ : [{ id: activeModel, name: activeModel }, ...rows];
+}
+
+/** True when the saved model is absent from a NON-empty catalog — the provider
+ * changed under us. Shown to the user instead of auto-picking another. */
+export function isStaleSelection(load: ModelLoad, rows: QuickCatalogModel[], activeModel: string): boolean {
+ return load.state === "ok" && rows.length > 0 && !!activeModel && !rows.some((row) => row.id === activeModel);
+}
+
+/** Non-2xx is an ERROR (never an empty list); 2xx with `models: []` honestly
+ * means "this provider has none". */
+export function modelsFromResponse(status: number, body: { models?: QuickCatalogModel[] }): { load: ModelLoad; rows: QuickCatalogModel[] } {
+ if (status < 200 || status >= 300) return { load: { state: "error", error: `HTTP ${status}` }, rows: [] };
+ return { load: { state: "ok" }, rows: Array.isArray(body.models) ? body.models : [] };
+}
+
+export function modelOptionText(row: QuickCatalogModel, activeModel: string): string {
+ return `${row.name || row.id}${row.id === activeModel ? " (current)" : ""}`;
+}
+
+/** Model half of the cockpit, split out so all three states are assertable markup:
+ * a failed fetch is an error + Retry (never an empty dropdown); a provider that
+ * genuinely lists nothing gets an explicit Discover affordance. */
+export function ModelPickerBody({
+ load, rows, activeModel, provider, saving, discovering, onReload, onDiscover, onSelect,
+}: {
+ load: ModelLoad; rows: QuickCatalogModel[]; activeModel: string; provider: string;
+ saving: boolean; discovering: boolean;
+ onReload: () => void; onDiscover: () => void; onSelect: (id: string) => void;
+}) {
+ const link = "ml-auto h-auto p-0 text-xs underline [@media(pointer:coarse)]:min-h-[44px]";
+ if (load.state === "error") {
+ return (
+ <div role="alert" className="flex items-center gap-2 rounded-md border border-destructive/40 px-2 py-1.5 text-xs text-destructive">
+ <TriangleAlert className="size-3 shrink-0" />
+ <span className="truncate">Couldn’t load {quickProviderLabel(provider)} models ({load.error})</span>
+ <Button type="button" variant="ghost" size="sm" className={link} onClick={onReload}>Retry</Button>
+ </div>
+ );
+ }
+ if (load.state === "ok" && rows.length === 0) {
+ return (
+ <div className="flex items-center gap-2 rounded-md border border-border px-2 py-1.5 text-xs text-muted-foreground">
+ <span className="truncate">{quickProviderLabel(provider)} reports no models.</span>
+ <Button type="button" variant="ghost" size="sm" className={`${link} text-primary`} disabled={discovering} onClick={onDiscover}>{discovering ? "Discovering…" : "Discover"}</Button>
+ </div>
+ );
+ }
+ return (
+ <Select value={activeModel} onValueChange={onSelect} disabled={saving || load.state !== "ok"}>
+ <SelectTrigger aria-label="Alfa model"><SelectValue placeholder={load.state === "loading" ? "Loading models…" : "Choose model"} /></SelectTrigger>
+ <ProviderSelectContent filterLabel="Filter Alfa models" groups={[{
+ label: quickProviderLabel(provider),
+ rows: modelOptions(rows, activeModel).slice(0, 80).map((row) => ({ id: row.id, text: modelOptionText(row, activeModel) })),
+ }]} />
+ </Select>
+ );
+}
+
+// Alfa cockpit model switcher: providers use the shared bounded/filterable list
+// (same cap as Settings → AI); models are that provider's real catalog from
+// /api/models?provider=…, persisted with POST /api/config.
export function ModelQuickControl({ provider, model, onSaved }: { provider: string; model: string; onSaved: () => void }) {
const [providerIds, setProviderIds] = useState<string[]>([provider]);
const [activeProvider, setActiveProvider] = useState(provider);
const [activeModel, setActiveModel] = useState(model);
- const [rows, setRows] = useState<QuickCatalogModel[]>([]);
+ // Request-keyed derived state: a settled result is only valid for the provider
+ // it was fetched for, so "loading" needs no setState inside the effect.
+ type Result = { key: string; load: ModelLoad; rows: QuickCatalogModel[] };
+ const [result, setResult] = useState<Result>({ key: "", load: { state: "loading" }, rows: [] });
const [saving, setSaving] = useState(false);
+ const [discovering, setDiscovering] = useState(false);
const [test, setTest] = useState<{ ok: boolean; text: string } | null>(null);
+ const [reloadKey, setReloadKey] = useState(0);
useEffect(() => {
const ctrl = new AbortController();
@@ -31,95 +104,107 @@ export function ModelQuickControl({ provider, model, onSaved }: { provider: stri
return () => ctrl.abort();
}, [provider]);
+ const requestKey = `${activeProvider}#${reloadKey}`;
+ const settled = result.key === requestKey ? result : null;
+ const load: ModelLoad = settled?.load ?? { state: "loading" };
+ const rows = settled?.rows ?? [];
+
useEffect(() => {
const ctrl = new AbortController();
fetch(`/api/models?provider=${encodeURIComponent(activeProvider)}`, { cache: "no-store", signal: ctrl.signal })
- .then((response) => response.ok ? response.json() : { models: [] })
- .then((body) => setRows((body.models ?? []) as QuickCatalogModel[]))
- .catch(() => setRows([]));
+ .then(async (response) => modelsFromResponse(response.status, (await response.json().catch(() => ({}))) as { models?: QuickCatalogModel[] }))
+ .then((next) => setResult({ key: requestKey, ...next }))
+ .catch((e: Error) => {
+ if (ctrl.signal.aborted) return;
+ // rows stay empty AND the state is "error": never an empty-list lie.
+ setResult({ key: requestKey, load: { state: "error", error: e.message || "Model list failed to load" }, rows: [] });
+ });
return () => ctrl.abort();
- }, [activeProvider]);
+ }, [activeProvider, requestKey]);
- const options = useMemo(
- () => rows.some((row) => row.id === activeModel) ? rows : activeModel ? [{ id: activeModel, name: activeModel }, ...rows] : rows,
- [activeModel, rows],
- );
+ const stale = isStaleSelection(load, rows, activeModel);
async function save(nextProvider: string, nextModel: string) {
const response = await fetch("/api/config", {
- method: "POST",
- headers: { "content-type": "application/json" },
+ method: "POST", headers: { "content-type": "application/json" },
body: JSON.stringify({ provider: nextProvider, model: nextModel }),
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
}
+ // Key stays server-side: the route reads it from the provider's credential.
+ async function discover() {
+ setDiscovering(true); setTest(null);
+ try {
+ const response = await fetch("/api/models/discover", {
+ method: "POST", headers: { "content-type": "application/json" },
+ body: JSON.stringify({ provider: activeProvider }),
+ });
+ const body = (await response.json().catch(() => ({}))) as { ok?: boolean; models?: QuickCatalogModel[]; error?: string };
+ if (!response.ok || body.ok === false) throw new Error(body.error || `HTTP ${response.status}`);
+ const found = body.models ?? [];
+ setResult({ key: requestKey, load: { state: "ok" }, rows: found });
+ setTest(found.length
+ ? { ok: true, text: `Found ${found.length} model${found.length === 1 ? "" : "s"} — pick one to save` }
+ : { ok: false, text: "Endpoint reachable but listed no models" });
+ } catch (e) { setTest({ ok: false, text: (e as Error).message || "Discovery failed" }); }
+ finally { setDiscovering(false); }
+ }
+
async function selectProvider(nextProvider: string) {
if (!nextProvider || nextProvider === activeProvider || saving) return;
- setSaving(true);
- setTest(null);
+ setSaving(true); setTest(null);
try {
const response = await fetch(`/api/models?provider=${encodeURIComponent(nextProvider)}`, { cache: "no-store" });
- const nextRows = response.ok ? (((await response.json()).models ?? []) as QuickCatalogModel[]) : [];
+ if (!response.ok) throw new Error(`HTTP ${response.status}`);
+ const nextRows = (((await response.json()).models ?? []) as QuickCatalogModel[]);
const nextModel = quickModelForProvider(nextProvider, nextRows, provider, model);
if (!nextModel) throw new Error("No selectable model");
await save(nextProvider, nextModel);
- setRows(nextRows);
+ setResult({ key: `${nextProvider}#${reloadKey}`, load: { state: "ok" }, rows: nextRows });
setActiveProvider(nextProvider);
setActiveModel(nextModel);
onSaved();
- } catch {
- setTest({ ok: false, text: "Provider switch failed" });
- } finally {
- setSaving(false);
- }
+ } catch { setTest({ ok: false, text: "Provider switch failed" }); }
+ finally { setSaving(false); }
}
async function selectModel(nextModel: string) {
if (!nextModel || nextModel === activeModel || saving) return;
- setSaving(true);
- setTest(null);
+ setSaving(true); setTest(null);
try {
await save(activeProvider, nextModel);
setActiveModel(nextModel);
onSaved();
- } catch {
- setTest({ ok: false, text: "Model switch failed" });
- } finally {
- setSaving(false);
- }
+ } catch { setTest({ ok: false, text: "Model switch failed" }); }
+ finally { setSaving(false); }
}
async function testSelected() {
- setSaving(true);
- setTest(null);
+ setSaving(true); setTest(null);
try {
const response = await fetch("/api/models/test", { method: "POST" });
const body = await response.json().catch(() => ({}));
setTest(body.ok ? { ok: true, text: "Connected" } : { ok: false, text: body.error || "Connection failed" });
- } catch {
- setTest({ ok: false, text: "Connection failed" });
- } finally {
- setSaving(false);
- }
+ } catch { setTest({ ok: false, text: "Connection failed" }); }
+ finally { setSaving(false); }
}
+ const providerGroups = useMemo(() => [{ label: "Connected",
+ rows: providerIds.map((id) => ({ id, text: quickProviderLabel(id) })) }], [providerIds]);
+
return (
<div className="space-y-2">
<div className="grid gap-2 sm:grid-cols-2">
<Select value={activeProvider} onValueChange={selectProvider} disabled={saving}>
<SelectTrigger aria-label="Alfa provider"><SelectValue /></SelectTrigger>
- <SelectContent position="popper" align="start">
- {providerIds.map((id) => <SelectItem key={id} value={id}>{quickProviderLabel(id)}</SelectItem>)}
- </SelectContent>
- </Select>
- <Select value={activeModel} onValueChange={selectModel} disabled={saving || !activeModel}>
- <SelectTrigger aria-label="Alfa model"><SelectValue placeholder="Choose model" /></SelectTrigger>
- <SelectContent position="popper" align="start">
- {options.slice(0, 80).map((row) => <SelectItem key={row.id} value={row.id}>{row.name || row.id}</SelectItem>)}
- </SelectContent>
+ <ProviderSelectContent groups={providerGroups} filterLabel="Filter Alfa providers" />
</Select>
+ <ModelPickerBody load={load} rows={rows} activeModel={activeModel} provider={activeProvider}
+ saving={saving} discovering={discovering} onReload={() => setReloadKey((k) => k + 1)}
+ onDiscover={() => void discover()} onSelect={(next) => void selectModel(next)} />
</div>
+ {stale ? <p className="text-[10px] text-warning" role="status">Saved model “{activeModel}” is not in the current list — pick another to switch, or Discover to refresh.</p> : null}
<Button size="sm" variant="outline" className="h-9" onClick={testSelected} disabled={saving}>
{saving ? <Loader2 className="size-3.5 animate-spin" /> : "Test active"}
</Button>
diff --git a/frontend/slices/os-settings/components/ai-provider-select.test.tsx b/frontend/slices/os-settings/components/ai-provider-select.test.tsx
new file mode 100644
index 00000000..0f7137ea
--- /dev/null
+++ b/frontend/slices/os-settings/components/ai-provider-select.test.tsx
@@ -0,0 +1,52 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import {
+ PROVIDER_LIST_CONTENT_CLASS,
+ PROVIDER_LIST_MAX_HEIGHT_REM,
+} from "./provider-filter-list";
+import { providerGroups } from "./ai-provider-select";
+import type { ProviderSummary } from "./ai-provider-options";
+import type { ConnectedProvider } from "./provider-list";
+
+const src = (path: string) => readFileSync(path, "utf8");
+
+// Both places that render a provider list must behave the same: one shared,
+// explicitly capped content. Duplicated markup drifted before; this locks it.
+describe("provider list call sites", () => {
+ it("renders the Settings list through the shared bounded component", () => {
+ expect(src("frontend/slices/os-settings/components/ai-provider-select.tsx")).toContain("ProviderSelectContent");
+ });
+
+ it("renders the Alfa cockpit provider list through the same component", () => {
+ expect(src("frontend/slices/assistant/components/model-quick-control.tsx")).toContain("ProviderSelectContent");
+ });
+
+ it("never leaves a viewport-derived max height in either call site", () => {
+ for (const path of [
+ "frontend/slices/os-settings/components/ai-provider-select.tsx",
+ "frontend/slices/assistant/components/model-quick-control.tsx",
+ "frontend/slices/os-settings/components/provider-filter-list.tsx",
+ ]) {
+ expect(src(path)).not.toContain("max-h-(--radix-select-content-available-height)");
+ }
+ expect(PROVIDER_LIST_CONTENT_CLASS).toContain(`max-h-[${PROVIDER_LIST_MAX_HEIGHT_REM}rem]`);
+ });
+
+ it("keeps the three Settings groups in order", () => {
+ const options: ProviderSummary[] = [
+ { id: "free", name: "Free", catalogId: "free", modelCount: 2, freeModelCount: 1, freeAgentModelCount: 1, recommendedFreeModel: "f" },
+ { id: "paid", name: "Paid", catalogId: "paid", modelCount: 2, freeModelCount: 0, freeAgentModelCount: 0, recommendedFreeModel: null },
+ ];
+ const connected: ConnectedProvider[] = [{ id: "ai-hub", kind: "custom", hasKey: true, masked: "sk-…" }];
+ const groups = providerGroups(options, connected);
+ expect(groups.map((group) => group.label)).toEqual(["Free AI available", "Other providers", "Connected"]);
+ expect(groups[0].rows[0].text).toContain("1 free agent-ready");
+ expect(groups[2].rows[0].text).toBe("ai-hub (Custom)");
+ });
+
+ it("omits a group that has no members instead of rendering an empty label", () => {
+ const groups = providerGroups([], [{ id: "codex", kind: "oauth", hasKey: true, masked: "signed in" }]);
+ expect(groups.map((group) => group.label)).toEqual(["Connected"]);
+ expect(groups[0].rows[0].text).toBe("codex (OAuth)");
+ });
+});
diff --git a/frontend/slices/os-settings/components/ai-provider-select.tsx b/frontend/slices/os-settings/components/ai-provider-select.tsx
index 3bf4a152..41e43eb1 100644
--- a/frontend/slices/os-settings/components/ai-provider-select.tsx
+++ b/frontend/slices/os-settings/components/ai-provider-select.tsx
@@ -1,11 +1,43 @@
"use client";
-import {
- Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectTrigger, SelectValue,
-} from "@/components/ui/select";
+import { Select, SelectTrigger, SelectValue } from "@/components/ui/select";
import { groupProviderOptions, type ProviderSummary } from "./ai-provider-options";
+import { ProviderSelectContent, type ProviderGroup } from "./provider-filter-list";
import { type ConnectedProvider } from "./provider-list";
+/** The Settings → AI provider list, grouped exactly as before but rendered by the
+ * shared bounded/filterable content so a long catalog cannot grow to viewport
+ * height. */
+export function providerGroups(
+ options: ProviderSummary[],
+ connectedExtras: ConnectedProvider[],
+): ProviderGroup[] {
+ const groups = groupProviderOptions(options);
+ const rows: ProviderGroup[] = [];
+ if (groups.free.length > 0) {
+ rows.push({
+ label: "Free AI available",
+ rows: groups.free.map((row) => ({
+ id: row.id,
+ text: `${row.name} · ${row.freeAgentModelCount} free agent-ready`,
+ })),
+ });
+ }
+ if (groups.other.length > 0) {
+ rows.push({ label: "Other providers", rows: groups.other.map((row) => ({ id: row.id, text: row.name })) });
+ }
+ if (connectedExtras.length > 0) {
+ rows.push({
+ label: "Connected",
+ rows: connectedExtras.map((row) => ({
+ id: row.id,
+ text: `${row.id}${row.kind === "oauth" ? " (OAuth)" : row.kind === "custom" ? " (Custom)" : ""}`,
+ })),
+ });
+ }
+ return rows;
+}
+
export function AiProviderSelect({
value,
options,
@@ -17,40 +49,12 @@ export function AiProviderSelect({
connectedExtras: ConnectedProvider[];
onChange: (value: string) => void;
}) {
- const groups = groupProviderOptions(options);
const selected = options.find((row) => row.id === value);
return (
<div className="space-y-1.5">
<Select value={value} onValueChange={onChange}>
<SelectTrigger className="sm:w-64"><SelectValue /></SelectTrigger>
- <SelectContent>
- {groups.free.length > 0 && (
- <SelectGroup>
- <SelectLabel>Free AI available</SelectLabel>
- {groups.free.map((row) => (
- <SelectItem key={row.id} value={row.id}>
- {row.name} · {row.freeAgentModelCount} free agent-ready
- </SelectItem>
- ))}
- </SelectGroup>
- )}
- {groups.other.length > 0 && (
- <SelectGroup>
- <SelectLabel>Other providers</SelectLabel>
- {groups.other.map((row) => <SelectItem key={row.id} value={row.id}>{row.name}</SelectItem>)}
- </SelectGroup>
- )}
- {connectedExtras.length > 0 && (
- <SelectGroup>
- <SelectLabel>Connected</SelectLabel>
- {connectedExtras.map((row) => (
- <SelectItem key={row.id} value={row.id}>
- {row.id}{row.kind === "oauth" ? " (OAuth)" : row.kind === "custom" ? " (Custom)" : ""}
- </SelectItem>
- ))}
- </SelectGroup>
- )}
- </SelectContent>
+ <ProviderSelectContent groups={providerGroups(options, connectedExtras)} />
</Select>
{selected && selected.freeAgentModelCount > 0 && (
<p className="text-xs text-muted-foreground">
diff --git a/frontend/slices/os-settings/components/custom-provider-form.test.tsx b/frontend/slices/os-settings/components/custom-provider-form.test.tsx
new file mode 100644
index 00000000..1b591cd2
--- /dev/null
+++ b/frontend/slices/os-settings/components/custom-provider-form.test.tsx
@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import {
+ DISCOVERY_MESSAGES,
+ baseUrlLooksValid,
+ claimDiscovery,
+ classifyDiscovery,
+ discoveryPairKey,
+ modelFieldFromDiscovered,
+ type DiscoveryFailure,
+} from "./custom-provider-form";
+
+// Complaint 2 ("susah add custom provider"): the three discovery failures must
+// stay distinct, and discovery must pre-select everything it finds.
+
+describe("discovery failure classification", () => {
+ it("keeps three different messages, one per failure kind", () => {
+ const kinds: DiscoveryFailure[] = ["invalid-url", "auth", "empty"];
+ const messages = kinds.map((kind) => DISCOVERY_MESSAGES[kind]);
+ expect(new Set(messages).size).toBe(3);
+ for (const message of messages) expect(message.length).toBeGreaterThan(20);
+ expect(DISCOVERY_MESSAGES.auth).toContain("401/403");
+ expect(DISCOVERY_MESSAGES["invalid-url"]).toMatch(/https:\/\//);
+ });
+
+ it("maps a rejected key to the auth message, not a generic error", () => {
+ expect(classifyDiscovery(401, {})).toBe("auth");
+ expect(classifyDiscovery(403, {})).toBe("auth");
+ expect(classifyDiscovery(200, { ok: false, error: "model discovery HTTP 401" })).toBe("auth");
+ });
+
+ it("maps a malformed/unsafe URL rejection separately from auth", () => {
+ expect(classifyDiscovery(400, { error: "Base URL is not a valid URL" })).toBe("invalid-url");
+ expect(classifyDiscovery(200, { ok: false, error: "model discovery request failed" })).toBe("invalid-url");
+ });
+
+ it("maps a reachable endpoint with an empty list to the no-models message", () => {
+ expect(classifyDiscovery(200, { ok: true, models: [] })).toBe("empty");
+ expect(classifyDiscovery(200, { ok: true })).toBe("empty");
+ expect(classifyDiscovery(200, { ok: false, error: "model discovery returned invalid JSON" })).toBe("empty");
+ });
+
+ it("returns null only when models actually came back", () => {
+ expect(classifyDiscovery(200, { ok: true, models: [{ id: "gpt-4o", name: "GPT-4o" }] })).toBeNull();
+ });
+});
+
+describe("auto-discovery guard", () => {
+ it("keys a run by the exact baseURL+key pair and refuses unusable pairs", () => {
+ expect(discoveryPairKey("", "sk-1")).toBeNull();
+ expect(discoveryPairKey("not-a-url", "sk-1")).toBeNull();
+ expect(discoveryPairKey("https://host/v1", " ")).toBeNull();
+ expect(discoveryPairKey("https://host/v1", "sk-1")).not.toBe(discoveryPairKey("https://host/v1", "sk-2"));
+ });
+
+ it("claims each pair at most once, so a debounce can never fire twice", () => {
+ const fired = new Set<string>();
+ const pair = discoveryPairKey("https://host/v1", "sk-1");
+ expect(claimDiscovery(fired, pair)).toBe(true);
+ expect(claimDiscovery(fired, pair)).toBe(false);
+ expect(claimDiscovery(fired, null)).toBe(false);
+ expect(claimDiscovery(fired, discoveryPairKey("https://host/v1", "sk-2"))).toBe(true);
+ });
+
+ it("only treats a real http(s) URL as valid", () => {
+ expect(baseUrlLooksValid("https://host/v1")).toBe(true);
+ expect(baseUrlLooksValid("http://10.0.0.2:8080/v1")).toBe(true);
+ expect(baseUrlLooksValid("host/v1")).toBe(false);
+ expect(baseUrlLooksValid("file:///etc/passwd")).toBe(false);
+ expect(baseUrlLooksValid("")).toBe(false);
+ });
+});
+
+describe("discovered models are pre-selected", () => {
+ it("puts every discovered id into the models field", () => {
+ expect(modelFieldFromDiscovered([{ id: "gpt-4o", name: "GPT-4o" }, { id: "o3", name: "o3" }]))
+ .toBe("gpt-4o, o3");
+ expect(modelFieldFromDiscovered([])).toBe("");
+ });
+});
diff --git a/frontend/slices/os-settings/components/custom-provider-form.tsx b/frontend/slices/os-settings/components/custom-provider-form.tsx
index 4a86a794..d133e52c 100644
--- a/frontend/slices/os-settings/components/custom-provider-form.tsx
+++ b/frontend/slices/os-settings/components/custom-provider-form.tsx
@@ -1,6 +1,6 @@
"use client";
-import { useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
import { toast } from "@/features/appshell";
import { Input } from "@/components/ui/input";
import { Textarea } from "@/components/ui/textarea";
@@ -8,16 +8,62 @@ import { Button } from "@/components/ui/button";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
import { parseCustomProviderConfig, parseModelList, toggleModelInList } from "./custom-provider-config";
-type DiscoveredModel = { id: string; name: string };
+export type DiscoveredModel = { id: string; name: string };
+export type DiscoveryFailure = "invalid-url" | "auth" | "empty";
+type Reply = { ok?: boolean; models?: DiscoveredModel[]; error?: string };
-// Add a custom OpenAI-compatible / Anthropic-Messages provider. Two input modes:
-// • fields — name / protocol / baseURL / key (+ optional comma/newline models)
-// • JSON — paste {name, baseURL, apiKey, protocol, models[]} whole
-// "Discover models" asks the endpoint's own list API (POST /api/models/discover,
-// SSRF-pinned, key sent only to that host) so the owner can pick ids instead of
-// guessing them; discovered ids are toggled as chips into the models field.
-// POSTs { customProvider } to /api/config (SSRF-checked, slug-reserved server-side);
-// the added provider is selected immediately. onAdded refreshes the parent.
+// Three actionable failures, never one generic "discovery failed": a malformed
+// base URL, a rejected key, and a reachable endpoint with no models need
+// different fixes. Exported so the messages are testable and stay distinct.
+export const DISCOVERY_MESSAGES: Record<DiscoveryFailure, string> = {
+ "invalid-url": "That endpoint URL isn’t usable — use a full https:// base URL (e.g. https://host/v1) that the server can reach.",
+ auth: "That endpoint rejected the API key (401/403). Check the key, then retry Discover.",
+ empty: "The endpoint answered but listed no models. Type the ids by hand or paste JSON instead.",
+};
+
+export function baseUrlLooksValid(value: string): boolean {
+ try {
+ const url = new URL(value.trim());
+ return (url.protocol === "http:" || url.protocol === "https:") && Boolean(url.hostname);
+ } catch {
+ return false;
+ }
+}
+
+/** Map a discovery response to a failure kind, or null when models came back.
+ * The route reports endpoint failures as `{ok:false,error}` with HTTP 200, so the
+ * status alone is not enough — the body has to be classified too. */
+export function classifyDiscovery(status: number, body: Reply): DiscoveryFailure | null {
+ const text = String(body.error ?? "");
+ if (status === 401 || status === 403 || /HTTP (401|403)/.test(text)) return "auth";
+ if (status >= 400) return "invalid-url"; // rejected body: malformed / unsafe URL
+ if (body.ok === false) return /no models|invalid JSON/i.test(text) ? "empty" : "invalid-url";
+ return Array.isArray(body.models) && body.models.length ? null : "empty";
+}
+
+/** The baseURL+key pair a discovery run is keyed by, or null until it is usable.
+ * Keyed by the pair so a re-render cannot re-fire it. */
+export function discoveryPairKey(baseURL: string, apiKey: string): string | null {
+ return baseUrlLooksValid(baseURL) && apiKey.trim() ? `${baseURL.trim()}\n${apiKey.trim()}` : null;
+}
+
+/** Claim the pair BEFORE fetching; false means "this pair already ran". */
+export function claimDiscovery(fired: Set<string>, pair: string | null): boolean {
+ if (!pair || fired.has(pair)) return false;
+ fired.add(pair);
+ return true;
+}
+
+/** Every discovered id into the delimited models field. Connecting a provider
+ * normally wants all of them; tapping chips one by one was the reported pain. */
+export function modelFieldFromDiscovered(list: DiscoveredModel[]): string {
+ return list.map((model) => model.id).join(", ");
+}
+
+// Add a custom OpenAI-compatible / Anthropic-Messages provider: fields or pasted
+// JSON. "Discover models" asks the endpoint's own list API (POST /api/models/discover,
+// SSRF-pinned, key only in the body) and PRE-SELECTS every returned id. It also runs
+// itself once per baseURL+key pair — debounced, cancellable; the button re-runs it.
export function CustomProviderForm({ onAdded }: { onAdded: () => void }) {
const [mode, setMode] = useState<"fields" | "json">("fields");
const [name, setName] = useState("");
@@ -29,127 +75,142 @@ export function CustomProviderForm({ onAdded }: { onAdded: () => void }) {
const [busy, setBusy] = useState(false);
const [found, setFound] = useState<DiscoveredModel[]>([]);
const [scanning, setScanning] = useState(false);
+ const [failure, setFailure] = useState<DiscoveryFailure | null>(null);
+ const autoFired = useRef<Set<string>>(new Set()); // pairs already auto-run
+ const abortRef = useRef<AbortController | null>(null);
- async function discover() {
+ const run = useCallback(async (signal: AbortSignal, target: string, apiKey: string, proto: string) => {
+ if (!baseUrlLooksValid(target) || !apiKey.trim()) {
+ setFailure("invalid-url");
+ return;
+ }
setScanning(true);
+ setFailure(null);
try {
- const r = await fetch("/api/models/discover", {
+ const response = await fetch("/api/models/discover", {
method: "POST",
headers: { "content-type": "application/json" },
- body: JSON.stringify({ baseURL, apiKey: key, protocol }),
+ body: JSON.stringify({ baseURL: target, apiKey, protocol: proto }),
+ signal,
});
- const d = (await r.json().catch(() => ({}))) as { ok?: boolean; count?: number; models?: DiscoveredModel[]; error?: string };
- if (!r.ok) {
- toast(d.error || "Couldn't reach that endpoint", { tone: "error" });
- return;
- }
- if (!d.ok || !d.models?.length) {
+ const body = (await response.json().catch(() => ({}))) as Reply;
+ const kind = classifyDiscovery(response.status, body);
+ if (kind) {
setFound([]);
- toast(d.error || "No models found at that endpoint", { tone: "error" });
+ setFailure(kind);
return;
}
- setFound(d.models);
- toast(`Discovered ${d.models.length} model${d.models.length === 1 ? "" : "s"} — tap to add`);
- } catch (e) {
- toast((e as Error).message || "Discovery failed", { tone: "error" });
+ const list = body.models ?? [];
+ setFound(list);
+ setModels(modelFieldFromDiscovered(list));
+ toast(`Discovered ${list.length} model${list.length === 1 ? "" : "s"} — all selected`);
+ } catch {
+ if (!signal.aborted) setFailure("invalid-url");
} finally {
- setScanning(false);
+ if (!signal.aborted) setScanning(false);
}
- }
+ }, []);
+
+ const start = useCallback((target: string, apiKey: string, proto: string) => {
+ abortRef.current?.abort(); // one discovery in flight, cancellable
+ const controller = new AbortController();
+ abortRef.current = controller;
+ void run(controller.signal, target, apiKey, proto);
+ }, [run]);
+ // Auto-discovery: 700 ms debounce, pair claimed before the fetch, aborted when
+ // the pair changes or the form unmounts. Never on every keystroke, never twice.
+ useEffect(() => {
+ if (mode !== "fields") return;
+ const pair = discoveryPairKey(baseURL, key);
+ if (!pair || autoFired.current.has(pair)) return;
+ const timer = setTimeout(() => {
+ if (claimDiscovery(autoFired.current, pair)) start(baseURL.trim(), key.trim(), protocol);
+ }, 700);
+ return () => window.clearTimeout(timer);
+ }, [baseURL, key, mode, protocol, start]);
+
+ useEffect(() => () => abortRef.current?.abort(), []);
+
+ // The route re-validates everything (SSRF, slug, key); this only reports it.
async function submit() {
setBusy(true);
try {
- const payload =
- mode === "json"
- ? parseCustomProviderConfig(json) // throws on bad JSON / missing fields
- : { name, baseURL, apiKey: key, protocol, models: parseModelList(models) };
- const r = await fetch("/api/config", {
- method: "POST",
- headers: { "content-type": "application/json" },
+ const payload = mode === "json"
+ ? parseCustomProviderConfig(json) // throws on bad JSON / missing fields
+ : { name, baseURL, apiKey: key, protocol, models: parseModelList(models) };
+ const response = await fetch("/api/config", {
+ method: "POST", headers: { "content-type": "application/json" },
body: JSON.stringify({ customProvider: payload }),
});
- const d = (await r.json().catch(() => ({}))) as { slug?: string; error?: string };
- if (!r.ok) {
- toast(d.error || "Couldn’t add provider", { tone: "error" });
- return;
- }
- setName(""); setBaseURL(""); setKey(""); setModels(""); setJson(""); setFound([]);
- toast(`Added ${d.slug ?? "provider"}`);
+ const body = (await response.json().catch(() => ({}))) as { slug?: string; error?: string };
+ if (!response.ok) return void toast(body.error || "Couldn’t add provider", { tone: "error" });
+ setName(""); setBaseURL(""); setKey(""); setModels(""); setJson(""); setFound([]); setFailure(null);
+ autoFired.current.clear(); // a fresh form starts with a fresh budget
+ toast(`Added ${body.slug ?? "provider"}`);
onAdded();
} catch (e) {
toast((e as Error).message || "Invalid config", { tone: "error" });
- } finally {
- setBusy(false);
- }
+ } finally { setBusy(false); }
}
+ const selectedIds = parseModelList(models);
const canSubmit = !busy && (mode === "json" ? !!json.trim() : !!name && !!baseURL && !!key);
+ const ghost = "h-auto p-0 text-xs hover:bg-transparent hover:underline [@media(pointer:coarse)]:min-h-[44px]";
return (
<div className="space-y-2 rounded-lg border border-border p-3">
<div className="flex items-center justify-between text-xs text-muted-foreground">
<span>Custom endpoint — OpenAI-compatible or Anthropic Messages</span>
- <Button
- type="button"
- variant="ghost"
- className="h-auto p-0 text-xs text-primary hover:bg-transparent hover:underline [@media(pointer:coarse)]:min-h-[44px]"
- onClick={() => setMode(mode === "fields" ? "json" : "fields")}
- >
+ <Button type="button" variant="ghost" className={`${ghost} text-primary`} onClick={() => setMode(mode === "fields" ? "json" : "fields")}>
{mode === "fields" ? "paste JSON" : "use fields"}
</Button>
</div>
-
{mode === "fields" ? (
<div className="space-y-2">
<div className="flex flex-wrap gap-2">
- <Input disabled={busy} placeholder="name (e.g. my-llm)" value={name} onChange={(e) => setName(e.target.value)} className="w-40" />
+ <Input disabled={busy} aria-label="Provider name" placeholder="name (e.g. my-llm)" value={name} onChange={(e) => setName(e.target.value)} className="w-40" />
<Select value={protocol} onValueChange={setProtocol}>
- <SelectTrigger className="w-52"><SelectValue /></SelectTrigger>
+ <SelectTrigger aria-label="Endpoint protocol" className="w-52"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem value="openai">OpenAI /chat/completions</SelectItem>
<SelectItem value="anthropic">Anthropic /v1/messages</SelectItem>
</SelectContent>
</Select>
</div>
- <Input disabled={busy} placeholder="https://host/v1" value={baseURL} onChange={(e) => setBaseURL(e.target.value)} />
- <Input disabled={busy} type="password" placeholder="API key" value={key} onChange={(e) => setKey(e.target.value)} />
+ <Input disabled={busy} aria-label="Base URL" placeholder="https://host/v1" value={baseURL} onChange={(e) => setBaseURL(e.target.value)} />
+ <Input disabled={busy} aria-label="API key" type="password" placeholder="API key" value={key} onChange={(e) => setKey(e.target.value)} />
<div className="flex items-center gap-2">
- <Input disabled={busy} placeholder="models (optional) — comma/newline, e.g. minimax-m3, gpt-4o" value={models} onChange={(e) => setModels(e.target.value)} className="flex-1" />
- <Button type="button" variant="outline" size="sm" className="[@media(pointer:coarse)]:min-h-[44px]" disabled={busy || scanning || !baseURL || !key} onClick={discover}>
+ <Input disabled={busy} aria-label="Models" placeholder="models — comma/newline, e.g. minimax-m3, gpt-4o" value={models} onChange={(e) => setModels(e.target.value)} className="flex-1" />
+ <Button type="button" variant="outline" size="sm" className="[@media(pointer:coarse)]:min-h-[44px]" disabled={busy || scanning || !baseURL || !key} onClick={() => start(baseURL, key, protocol)}>
{scanning ? "Discovering…" : "Discover models"}
</Button>
</div>
+ {failure ? <p role="alert" className="text-xs text-destructive">{DISCOVERY_MESSAGES[failure]}</p> : null}
{found.length > 0 && (
- <div className="flex flex-wrap gap-1.5">
- {found.map((m) => {
- const on = parseModelList(models).includes(m.id);
- return (
- <button
- key={m.id}
- type="button"
- title={m.name}
- onClick={() => setModels((prev) => toggleModelInList(prev, m.id))}
- className={`rounded-md border px-2 py-1 font-mono text-xs [@media(pointer:coarse)]:min-h-[44px] ${on ? "border-primary bg-primary/10 text-primary" : "border-border text-muted-foreground"}`}
- >
- {m.id}
+ <div className="space-y-1.5">
+ <div className="flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
+ <span>{found.length} found · {selectedIds.length} selected</span>
+ <Button type="button" variant="ghost" size="sm" className={`${ghost} text-primary`} onClick={() => setModels(modelFieldFromDiscovered(found))}>Select all</Button>
+ <Button type="button" variant="ghost" size="sm" className={ghost} onClick={() => setModels("")}>Clear</Button>
+ </div>
+ <div className="flex flex-wrap gap-1.5">
+ {found.map((model) => (
+ <button key={model.id} type="button" title={model.name} aria-pressed={selectedIds.includes(model.id)}
+ onClick={() => setModels((prev) => toggleModelInList(prev, model.id))}
+ className={`rounded-md border px-2 py-1 font-mono text-xs [@media(pointer:coarse)]:min-h-[44px] ${selectedIds.includes(model.id) ? "border-primary bg-primary/10 text-primary" : "border-border text-muted-foreground"}`}>
+ {model.id}
</button>
- );
- })}
+ ))}
+ </div>
</div>
)}
</div>
) : (
- <Textarea
- disabled={busy}
- rows={7}
- className="font-mono text-xs"
- value={json}
+ <Textarea disabled={busy} rows={7} className="font-mono text-xs" value={json} aria-label="Custom provider JSON"
onChange={(e) => setJson(e.target.value)}
- placeholder={'{\n "name": "ai-hub",\n "baseURL": "https://host/v1",\n "apiKey": "sk-…",\n "protocol": "openai",\n "models": ["minimax-m3", "gpt-4o"]\n}'}
- />
+ placeholder={'{\n "name": "ai-hub",\n "baseURL": "https://host/v1",\n "apiKey": "sk-…",\n "protocol": "openai",\n "models": ["minimax-m3", "gpt-4o"]\n}'} />
)}
-
<div className="flex justify-end">
<Button size="sm" className="[@media(pointer:coarse)]:min-h-[44px]" disabled={!canSubmit} onClick={submit}>{busy ? "Adding…" : "Add provider"}</Button>
</div>
diff --git a/frontend/slices/os-settings/components/provider-filter-list.test.tsx b/frontend/slices/os-settings/components/provider-filter-list.test.tsx
new file mode 100644
index 00000000..0474398e
--- /dev/null
+++ b/frontend/slices/os-settings/components/provider-filter-list.test.tsx
@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from "vitest";
+import { renderToStaticMarkup } from "react-dom/server";
+import type { ReactNode } from "react";
+import {
+ PROVIDER_FILTER_THRESHOLD,
+ PROVIDER_LIST_CONTENT_CLASS,
+ PROVIDER_LIST_MAX_HEIGHT_REM,
+ ProviderListBody,
+ ProviderSelectContent,
+ filterProviderGroups,
+ type ProviderGroup,
+} from "./provider-filter-list";
+
+// The real Radix SelectItem throws outside a SelectContent context and portals
+// never render server-side, so the primitives are stubbed with plain elements
+// here. That is exactly what is under test: the markup these components emit.
+vi.mock("@/components/ui/select", () => ({
+ SelectContent: ({ children, className }: { children: ReactNode; className?: string }) => (
+ <div data-slot="select-content" className={className}>{children}</div>
+ ),
+ SelectGroup: ({ children }: { children: ReactNode }) => <div data-slot="select-group">{children}</div>,
+ SelectItem: ({ children, className }: { children: ReactNode; className?: string }) => (
+ <div data-slot="select-item" className={className}>{children}</div>
+ ),
+ SelectLabel: ({ children }: { children: ReactNode }) => <div data-slot="select-label">{children}</div>,
+}));
+vi.mock("@/components/ui/input", () => ({
+ Input: ({ className, ...props }: Record<string, unknown>) => <input className={className as string} {...props} />,
+}));
+
+const groups: ProviderGroup[] = [
+ { label: "Free AI available", rows: [{ id: "groq", text: "Groq · 3 free agent-ready" }] },
+ { label: "Other providers", rows: [{ id: "anthropic", text: "Anthropic" }, { id: "openai", text: "OpenAI Platform" }] },
+ { label: "Connected", rows: [{ id: "ai-hub", text: "ai-hub (Custom)" }] },
+];
+
+const many: ProviderGroup[] = [{
+ label: "Other providers",
+ rows: Array.from({ length: PROVIDER_FILTER_THRESHOLD + 2 }, (_, i) => ({ id: `p${i}`, text: `Provider ${i}` })),
+}];
+
+// The reported bug: the dropdown grew to near-viewport height. Both assertions
+// below fail against the old `max-h-(--radix-select-content-available-height)`.
+describe("bounded provider list", () => {
+ it("caps the content height explicitly and scrolls internally", () => {
+ expect(PROVIDER_LIST_MAX_HEIGHT_REM).toBeGreaterThanOrEqual(18);
+ expect(PROVIDER_LIST_MAX_HEIGHT_REM).toBeLessThanOrEqual(20);
+ expect(PROVIDER_LIST_CONTENT_CLASS).toContain(`max-h-[${PROVIDER_LIST_MAX_HEIGHT_REM}rem]`);
+ expect(PROVIDER_LIST_CONTENT_CLASS).toContain("overflow-y-auto");
+ expect(PROVIDER_LIST_CONTENT_CLASS).not.toContain("--radix-select-content-available-height");
+ const html = renderToStaticMarkup(<ProviderSelectContent groups={groups} />);
+ expect(html).toContain(`max-h-[${PROVIDER_LIST_MAX_HEIGHT_REM}rem]`);
+ expect(html).toContain("overflow-y-auto");
+ });
+
+ it("keeps every option reachable — the cap never drops a row", () => {
+ const html = renderToStaticMarkup(<ProviderListBody groups={groups} />);
+ for (const group of groups) {
+ expect(html).toContain(group.label);
+ for (const row of group.rows) expect(html).toContain(row.text);
+ }
+ });
+
+ it("keeps the 44px coarse-pointer touch target on each option", () => {
+ expect(renderToStaticMarkup(<ProviderListBody groups={groups} />)).toContain("min-h-[44px]");
+ });
+});
+
+describe("provider filter", () => {
+ it("hides non-matching options and drops groups whose members all filtered out", () => {
+ const filtered = filterProviderGroups(groups, "openai");
+ expect(filtered.map((group) => group.label)).toEqual(["Other providers"]);
+ expect(filtered[0].rows.map((row) => row.id)).toEqual(["openai"]);
+ expect(filterProviderGroups(groups, "zzz")).toEqual([]);
+ });
+
+ it("matches the visible text as well as the id, and ignores blank queries", () => {
+ expect(filterProviderGroups(groups, "CUSTOM").map((group) => group.label)).toEqual(["Connected"]);
+ expect(filterProviderGroups(groups, " ")).toHaveLength(groups.length);
+ });
+
+ it("offers a labelled filter input only once the list is long (keyboard users type, not scroll)", () => {
+ expect(renderToStaticMarkup(<ProviderListBody groups={groups} />)).not.toContain("Type to filter");
+ const html = renderToStaticMarkup(<ProviderListBody groups={many} filterLabel="Filter providers" />);
+ expect(html).toContain("Type to filter");
+ expect(html).toContain('aria-label="Filter providers"');
+ // The input sits inside the content, above the scroll region, and is not
+ // wrapped in a focus trap of its own (Radix keeps focus in the content).
+ expect(html.indexOf("Type to filter")).toBeLessThan(html.indexOf("Provider 0"));
+ });
+
+ it("labels each group so filtering keeps labels coherent", () => {
+ const html = renderToStaticMarkup(<ProviderListBody groups={groups} />);
+ expect(html.match(/select-label/g)?.length).toBe(groups.length);
+ });
+});
diff --git a/frontend/slices/os-settings/components/provider-filter-list.tsx b/frontend/slices/os-settings/components/provider-filter-list.tsx
new file mode 100644
index 00000000..071fbee7
--- /dev/null
+++ b/frontend/slices/os-settings/components/provider-filter-list.tsx
@@ -0,0 +1,129 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import { Input } from "@/components/ui/input";
+import { SelectContent, SelectGroup, SelectItem, SelectLabel } from "@/components/ui/select";
+
+// One bounded provider list for every place that renders providers (Settings → AI
+// and the Alfa cockpit). The content is capped at a fixed height instead of a
+// viewport-derived one, so a long catalog can never grow to viewport height. Radix's viewport stays THE scroll container, so every
+// option is still reachable by wheel, scroll buttons and keyboard — the cap never
+// hides options without a way to reach them.
+//
+// 18rem ≈ 7 rows of 2.5rem plus the filter row: enough to compare providers side
+// by side, under half of a 768px-tall laptop viewport, and still scrollable on a
+// phone. 20rem would push the trigger off small landscape viewports with no gain.
+export const PROVIDER_LIST_MAX_HEIGHT_REM = 18;
+export const PROVIDER_LIST_CONTENT_CLASS = "max-h-[18rem] overflow-y-auto overflow-x-hidden";
+export const PROVIDER_FILTER_THRESHOLD = 8;
+
+export type ProviderRow = { id: string; text: string };
+export type ProviderGroup = { label: string; rows: ProviderRow[] };
+
+/** Case-insensitive match on the option id or its visible text. Groups whose
+ * members are all filtered out are dropped, so no orphan label survives. */
+export function filterProviderGroups(groups: ProviderGroup[], query: string): ProviderGroup[] {
+ const needle = query.trim().toLowerCase();
+ if (!needle) return groups;
+ return groups
+ .map((group) => ({
+ label: group.label,
+ rows: group.rows.filter(
+ (row) => row.id.toLowerCase().includes(needle) || row.text.toLowerCase().includes(needle),
+ ),
+ }))
+ .filter((group) => group.rows.length > 0);
+}
+
+export function countProviderRows(groups: ProviderGroup[]): number {
+ return groups.reduce((total, group) => total + group.rows.length, 0);
+}
+
+/** Options only — no Radix portal — so it can be asserted in a plain render.
+ * Shows the type-to-filter input only past the threshold; a user with a handful
+ * of providers still gets the plain list. */
+export function ProviderListBody({
+ groups,
+ filterLabel = "Filter providers",
+ emptyLabel = "No providers match that filter.",
+}: {
+ groups: ProviderGroup[];
+ filterLabel?: string;
+ emptyLabel?: string;
+}) {
+ const [query, setQuery] = useState("");
+ const inputRef = useRef<HTMLInputElement>(null);
+ const filterable = countProviderRows(groups) > PROVIDER_FILTER_THRESHOLD;
+ const visible = filterProviderGroups(groups, query);
+
+ // Focus the filter after Radix focuses the selected item so a keyboard user can
+ // type instead of scrolling. Skipped on coarse pointers (no unasked soft
+ // keyboard). Focus stays inside Radix's FocusScope either way.
+ useEffect(() => {
+ if (!filterable) return;
+ if (typeof window !== "undefined" && window.matchMedia?.("(pointer: coarse)").matches) return;
+ const timer = setTimeout(() => inputRef.current?.focus(), 0);
+ return () => clearTimeout(timer);
+ }, [filterable]);
+
+ return (
+ <>
+ {filterable ? (
+ <div className="sticky top-0 z-10 -mx-1 border-b border-border bg-popover px-2 py-1.5">
+ <Input
+ ref={inputRef}
+ aria-label={filterLabel}
+ autoComplete="off"
+ placeholder="Type to filter…"
+ value={query}
+ onChange={(event) => setQuery(event.target.value)}
+ onKeyDown={(event) => {
+ // The input owns printable characters; Radix would otherwise treat
+ // them as typeahead and jump the focused option. Arrows and Tab
+ // still bubble so focus can move into the options.
+ if (event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey) {
+ event.stopPropagation();
+ }
+ }}
+ className="h-8 text-sm"
+ />
+ </div>
+ ) : null}
+ {visible.map((group) => (
+ <SelectGroup key={group.label}>
+ <SelectLabel>{group.label}</SelectLabel>
+ {group.rows.map((row) => (
+ <SelectItem key={row.id} value={row.id} className="[@media(pointer:coarse)]:min-h-[44px]">
+ {row.text}
+ </SelectItem>
+ ))}
+ </SelectGroup>
+ ))}
+ {visible.length === 0 ? (
+ <p className="px-2 py-1.5 text-xs text-muted-foreground">
+ {emptyLabel}
+ {query.trim() ? ` (${query.trim()})` : ""}
+ </p>
+ ) : null}
+ </>
+ );
+}
+
+/** The bounded, scrollable content shared by both provider selects. */
+export function ProviderSelectContent({
+ groups,
+ position = "popper",
+ filterLabel,
+ emptyLabel,
+}: {
+ groups: ProviderGroup[];
+ position?: "item-aligned" | "popper";
+ filterLabel?: string;
+ emptyLabel?: string;
+}) {
+ return (
+ <SelectContent position={position} align="start" className={PROVIDER_LIST_CONTENT_CLASS}>
+ <ProviderListBody groups={groups} filterLabel={filterLabel} emptyLabel={emptyLabel} />
+ </SelectContent>
+ );
+}
diff --git a/frontend/slices/os-settings/components/provider-list.test.tsx b/frontend/slices/os-settings/components/provider-list.test.tsx
new file mode 100644
index 00000000..1b0436ca
--- /dev/null
+++ b/frontend/slices/os-settings/components/provider-list.test.tsx
@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { renderToStaticMarkup } from "react-dom/server";
+import { ProviderList } from "./provider-list";
+import { ProviderManage } from "./provider-manage";
+
+// Complaint 2: adding a custom provider must be visible, and the collapsed state
+// must explain what the affordance does. Complaint 3 needs the connected list to
+// say plainly whether a provider has models.
+describe("custom provider affordance", () => {
+ it("labels the collapsed add-custom-provider control and exposes expand state", () => {
+ const html = renderToStaticMarkup(<ProviderManage providers={[]} selected="anthropic" reload={() => {}} />);
+ expect(html).toContain("Add custom provider");
+ expect(html).toContain('aria-expanded="false"');
+ expect(html).toContain('aria-controls="custom-provider-form"');
+ expect(html).toContain("Discover to pull in the model ids");
+ // Collapsed: the form itself is not mounted until asked for.
+ expect(html).not.toContain("Custom endpoint —");
+ });
+});
+
+describe("connected provider list", () => {
+ it("shows a custom provider's model count", () => {
+ const html = renderToStaticMarkup(
+ <ProviderList
+ providers={[{ id: "ai-hub", kind: "custom", hasKey: true, masked: "sk-…", models: ["a", "b"] }]}
+ selected="anthropic"
+ onChanged={() => {}}
+ />,
+ );
+ expect(html).toContain("2 models");
+ });
+
+ it("says a custom provider has no models yet instead of leaving it blank", () => {
+ const html = renderToStaticMarkup(
+ <ProviderList
+ providers={[{ id: "ai-hub", kind: "custom", hasKey: true, masked: "sk-…", models: [] }]}
+ selected="ai-hub"
+ onChanged={() => {}}
+ />,
+ );
+ expect(html).toContain("no models yet");
+ expect(html).toContain("active");
+ });
+
+ it("keeps a labelled remove control per provider", () => {
+ const html = renderToStaticMarkup(
+ <ProviderList
+ providers={[{ id: "ai-hub", kind: "custom", hasKey: true, masked: "sk-…" }]}
+ selected="ai-hub"
+ onChanged={() => {}}
+ />,
+ );
+ expect(html).toContain('aria-label="Remove ai-hub"');
+ });
+});
diff --git a/frontend/slices/os-settings/components/provider-list.tsx b/frontend/slices/os-settings/components/provider-list.tsx
index 991ead37..cc6f4069 100644
--- a/frontend/slices/os-settings/components/provider-list.tsx
+++ b/frontend/slices/os-settings/components/provider-list.tsx
@@ -51,6 +51,11 @@ export function ProviderList({
{p.id === selected && (
<span className="rounded bg-primary/15 px-1.5 py-0.5 text-[11px] text-primary">active</span>
)}
+ {p.kind === "custom" && (
+ <span className="text-[11px] text-muted-foreground">
+ {p.models?.length ? `${p.models.length} model${p.models.length === 1 ? "" : "s"}` : "no models yet"}
+ </span>
+ )}
<span className="ml-auto truncate text-xs text-muted-foreground">{p.baseUrl || p.masked}</span>
<Button
size="icon"
diff --git a/frontend/slices/os-settings/components/provider-manage.tsx b/frontend/slices/os-settings/components/provider-manage.tsx
index e214989b..a8423422 100644
--- a/frontend/slices/os-settings/components/provider-manage.tsx
+++ b/frontend/slices/os-settings/components/provider-manage.tsx
@@ -28,11 +28,19 @@ export function ProviderManage({
</SettingsBlock>
<SettingsBlock>
- <Button variant="ghost" size="sm" className="text-muted-foreground [@media(pointer:coarse)]:min-h-[44px]" onClick={() => setShowAdd((s) => !s)}>
- <Plus className="size-3.5" /> Add custom provider
+ <Button
+ variant="ghost"
+ size="sm"
+ aria-expanded={showAdd}
+ aria-controls="custom-provider-form"
+ className="text-muted-foreground [@media(pointer:coarse)]:min-h-[44px]"
+ onClick={() => setShowAdd((s) => !s)}
+ >
+ <Plus className={`size-3.5 transition-transform ${showAdd ? "rotate-45" : ""}`} />
+ {showAdd ? "Close custom provider form" : "Add custom provider"}
</Button>
- {showAdd && (
- <div className="mt-2">
+ {showAdd ? (
+ <div id="custom-provider-form" className="mt-2">
<CustomProviderForm
onAdded={() => {
setShowAdd(false);
@@ -40,6 +48,11 @@ export function ProviderManage({
}}
/>
</div>
+ ) : (
+ <p className="mt-1 text-xs text-muted-foreground">
+ Any OpenAI-compatible or Anthropic-Messages endpoint — paste its base URL and key,
+ then Discover to pull in the model ids it serves.
+ </p>
)}
</SettingsBlock>