Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

Unsloth Studio / Desktop: reload llama.cpp models on reconnect (#11341)

Maheswar Kumarc72fa043d983
diff --git a/studio/frontend/src/app/routes/__root.tsx b/studio/frontend/src/app/routes/__root.tsx
index da24154925d..b53dba3f9b1 100644
--- a/studio/frontend/src/app/routes/__root.tsx
+++ b/studio/frontend/src/app/routes/__root.tsx
@@ -23,6 +23,7 @@ import {
clearNewChatDraft,
hydrateModelDisclaimerPreference,
openFolderAsProject,
+ startLlamaCppAutoReload,
StopRunningChatsDialog,
useOpeningFolder,
useChatRuntimeStore,
@@ -253,6 +254,10 @@ function CredentialBootstrapGate({
window.removeEventListener(AUTH_SESSION_STORED_EVENT, reconcile);
};
}, [active]);
+ useEffect(() => {
+ if (active && ready) return startLlamaCppAutoReload();
+ }, [active, ready]);
+
return (
<>
<SettingsDialogMount active={active && ready} />
diff --git a/studio/frontend/src/features/chat/chat-providers-dialog.tsx b/studio/frontend/src/features/chat/chat-providers-dialog.tsx
index a537ed44b96..993484fe672 100644
--- a/studio/frontend/src/features/chat/chat-providers-dialog.tsx
+++ b/studio/frontend/src/features/chat/chat-providers-dialog.tsx
@@ -80,7 +80,10 @@ import {
supportsRemoteModelCatalog,
toExternalBackendProviderType,
} from "./external-providers";
-import { useExternalProvidersStore } from "./stores/external-providers-store";
+import {
+ providerSavesInFlight,
+ useExternalProvidersStore,
+} from "./stores/external-providers-store";
import {
mergeLearnedModelCapabilities,
pruneProviderModelIds,
@@ -279,6 +282,8 @@ export function ChatProvidersSettings({
CUSTOM_PROVIDER_DISPLAY_NAME,
);
const [isReasoningModel, setIsReasoningModel] = useState(false);
+ const [autoReloadModels, setAutoReloadModels] = useState(false);
+ const modelFieldsAtOpenRef = useRef<string | null>(null);
const reduceMotion = useReducedMotion();
const connectionsEnabled = useExternalProvidersStore(
(s) => s.connectionsEnabled,
@@ -528,6 +533,8 @@ export function ChatProvidersSettings({
setModelSearchQuery("");
setCustomProviderName(customProviderDisplayName(providerType));
setIsReasoningModel(false);
+ setAutoReloadModels(false);
+ modelFieldsAtOpenRef.current = null;
}
function openAddProvider() {
@@ -900,6 +907,8 @@ export function ChatProvidersSettings({
authKind: created.auth_kind,
authStatus: created.auth_status,
+ autoReloadModels:
+ uiProviderType === "llama_cpp" ? autoReloadModels : undefined,
isReasoningModel: supportsProviderReasoningToggle(uiProviderType)
? isReasoningModel
: undefined,
@@ -907,7 +916,7 @@ export function ChatProvidersSettings({
updatedAt,
};
onProvidersChange([
- ...providers.filter((p) => p.id !== created.id),
+ ...useExternalProvidersStore.getState().providers.filter((p) => p.id !== created.id),
provider,
]);
void refreshProviderModelCatalogs([provider]);
@@ -998,7 +1007,16 @@ export function ChatProvidersSettings({
return;
}
}
+ // Untouched model fields are left out of the save, so an auto reload landing before or during it stands.
+ const keepSavedModels =
+ existing.providerType === "llama_cpp" &&
+ modelFieldsAtOpenRef.current ===
+ JSON.stringify([selectedModelIds, manualIds, availableModels]);
+ const availableModelsToSave = manualOnly
+ ? []
+ : pruneProviderModelIds(existing.providerType, availableModels);
setMutatingProvider(true);
+ providerSavesInFlight.add(editingProviderId);
try {
const baseUrl = parseBaseUrlForProvider(
baseUrlDraft,
@@ -1015,10 +1033,8 @@ export function ChatProvidersSettings({
: existing.name,
baseUrl,
apiType: providerType === LEGACY_CUSTOM_PROVIDER_TYPE ? apiType : undefined,
- models: modelsToSave,
- availableModels: manualOnly
- ? []
- : pruneProviderModelIds(existing.providerType, availableModels),
+ models: keepSavedModels ? undefined : modelsToSave,
+ availableModels: keepSavedModels ? undefined : availableModelsToSave,
maxOutputTokens,
...(credentialEdit.action === "replace"
? { apiKey: credentialEdit.apiKey }
@@ -1042,13 +1058,17 @@ export function ChatProvidersSettings({
name: updated.display_name,
baseUrl: updated.base_url ?? "",
apiType: updated.api_type ?? "chat_completions",
- models: modelsToSave,
- availableModels: manualOnly
- ? []
- : pruneProviderModelIds(existing.providerType, availableModels),
+ models: keepSavedModels
+ ? (updated.models?.length ? updated.models : existing.models)
+ : modelsToSave,
+ availableModels: keepSavedModels
+ ? (updated.available_models?.length ? updated.available_models : existing.availableModels)
+ : availableModelsToSave,
maxOutputTokens: updated.max_output_tokens ?? undefined,
hasApiKey: updated.has_api_key,
+ autoReloadModels:
+ existing.providerType === "llama_cpp" ? autoReloadModels : undefined,
isReasoningModel: supportsProviderReasoningToggle(
existing.providerType,
)
@@ -1056,8 +1076,9 @@ export function ChatProvidersSettings({
: undefined,
updatedAt,
};
+ // Live store, not the render snapshot: auto reload may have written during the await.
onProvidersChange(
- providers.map((provider) =>
+ useExternalProvidersStore.getState().providers.map((provider) =>
provider.id === editingProviderId ? editedProvider : provider,
),
);
@@ -1070,6 +1091,7 @@ export function ChatProvidersSettings({
const message = error instanceof Error ? error.message : "Unknown error";
toast.error(`Failed to update connection: ${message}`);
} finally {
+ providerSavesInFlight.delete(editingProviderId);
setMutatingProvider(false);
}
}
@@ -1151,6 +1173,8 @@ export function ChatProvidersSettings({
setClearApiKeyRequested(false);
setShowApiKey(false);
setBaseUrlDraft(provider.baseUrl);
+ setAutoReloadModels(provider.autoReloadModels === true);
+ modelFieldsAtOpenRef.current = null;
setApiType(provider.apiType ?? "chat_completions");
// Seeded at the floor: parseMaxOutputTokens throws below it, so a row stored under one would
// fail every unrelated edit. The resolver already reads it as the floor.
@@ -1189,12 +1213,11 @@ export function ChatProvidersSettings({
]);
setAvailableModels(catalogModels);
const catalogSet = new Set(catalogModels);
- setSelectedModelIds(
- provider.models.filter((model) => catalogSet.has(model)),
- );
- setManualModelIds(
- provider.models.filter((model) => !catalogSet.has(model)).join("\n"),
- );
+ const selected = provider.models.filter((model) => catalogSet.has(model));
+ const manual = provider.models.filter((model) => !catalogSet.has(model));
+ setSelectedModelIds(selected);
+ setManualModelIds(manual.join("\n"));
+ modelFieldsAtOpenRef.current = JSON.stringify([selected, manual, catalogModels]);
return;
}
if (provider.authKind === "chatgpt_oauth") {
@@ -1262,7 +1285,9 @@ export function ChatProvidersSettings({
await deleteProviderConfig(providerId);
removeExternalProviderApiKey(providerId);
onProvidersChange(
- providers.filter((provider) => provider.id !== providerId),
+ useExternalProvidersStore.getState().providers.filter(
+ (provider) => provider.id !== providerId,
+ ),
);
} catch (error) {
const message = error instanceof Error ? error.message : "Unknown error";
@@ -1652,6 +1677,31 @@ export function ChatProvidersSettings({
</div>
) : null}
+ {providerType === "llama_cpp" ? (
+ <div className="flex items-center justify-between gap-4 px-4 py-3">
+ <div className="space-y-1">
+ <Label
+ htmlFor="provider-auto-reload-models"
+ className="text-sm font-medium"
+ >
+ Reload models automatically on connect
+ </Label>
+ <p
+ id="provider-auto-reload-models-help"
+ className="text-xs text-muted-foreground"
+ >
+ Refresh once on connect and after a disconnect while Studio is open.
+ New model IDs are enabled automatically. Saved in this browser.
+ </p>
+ </div>
+ <Switch
+ id="provider-auto-reload-models"
+ checked={autoReloadModels}
+ onCheckedChange={setAutoReloadModels}
+ aria-describedby="provider-auto-reload-models-help"
+ />
+ </div>
+ ) : null}
{showReasoningToggle ? (
<div className="grid grid-cols-[minmax(140px,0.8fr)_minmax(0,1.2fr)] items-center gap-4 px-4 py-3 @max-[520px]:grid-cols-1">
<Label
diff --git a/studio/frontend/src/features/chat/external-providers.ts b/studio/frontend/src/features/chat/external-providers.ts
index 82abee9256c..13deb4df595 100644
--- a/studio/frontend/src/features/chat/external-providers.ts
+++ b/studio/frontend/src/features/chat/external-providers.ts
@@ -42,6 +42,8 @@ export interface ExternalProviderConfig {
promptCacheTtl?: "5m" | "1h";
/** User-pinned: the loaded vLLM model supports `enable_thinking`. */
isReasoningModel?: boolean;
+ /** llama.cpp only, this browser only: reload models on connect and reconnect. */
+ autoReloadModels?: boolean;
/** Default idle-timeout (minutes) for new OpenAI shell containers. Pre-fills the create dialog
* and is the TTL the auto-create-per-thread path POSTs. OpenAI's hard default is 20. */
openaiContainerTtlMinutes?: number;
@@ -545,6 +547,8 @@ function normalizeProvider(raw: ExternalProviderConfig): ExternalProviderConfig
isReasoningModel: supportsProviderReasoningToggle(providerType)
? raw.isReasoningModel === true
: undefined,
+ autoReloadModels:
+ providerType === "llama_cpp" ? raw.autoReloadModels === true : undefined,
openaiContainerTtlMinutes:
providerType === "openai" &&
typeof raw.openaiContainerTtlMinutes === "number" &&
diff --git a/studio/frontend/src/features/chat/index.ts b/studio/frontend/src/features/chat/index.ts
index b4fdc2a28f6..ebd6abc1160 100644
--- a/studio/frontend/src/features/chat/index.ts
+++ b/studio/frontend/src/features/chat/index.ts
@@ -536,3 +536,5 @@ export {
type ComposerSubmitIntent,
} from "./utils/composer-preferences";
export { isTextAttachmentName } from "./text-attachment-accept";
+
+export { startLlamaCppAutoReload } from "./llama-cpp-auto-reload";
diff --git a/studio/frontend/src/features/chat/llama-cpp-auto-reload.ts b/studio/frontend/src/features/chat/llama-cpp-auto-reload.ts
new file mode 100644
index 00000000000..042a1b13e1e
--- /dev/null
+++ b/studio/frontend/src/features/chat/llama-cpp-auto-reload.ts
@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import {
+ listProviderConfigs,
+ listProviderModels,
+ updateProviderConfig,
+} from "./api/providers-api";
+import {
+ getExternalProviderApiKey,
+ type ExternalProviderConfig,
+} from "./external-providers";
+import {
+ providerSavesInFlight,
+ useExternalProvidersStore,
+} from "./stores/external-providers-store";
+
+/** Keeps manual IDs and the user's picks, drops IDs the server no longer lists, enables new ones. */
+export function mergeReloadedModels(
+ models: readonly string[],
+ previousCatalog: readonly string[],
+ catalog: readonly string[],
+): string[] {
+ const known = new Set(previousCatalog);
+ const live = new Set(catalog);
+ const selected = new Set(models);
+ const next = new Set([
+ ...models.filter((id) => !known.has(id) && !live.has(id)),
+ ...catalog.filter((id) => selected.has(id) || !known.has(id)),
+ ]);
+ return next.size > 0 ? [...next] : [...catalog];
+}
+
+const sameList = (a: readonly string[], b: readonly string[]) =>
+ a.length === b.length && a.every((id, i) => id === b[i]);
+
+function autoReloadConnections(): ExternalProviderConfig[] {
+ const { providers, connectionsEnabled } = useExternalProvidersStore.getState();
+ if (!connectionsEnabled) return [];
+ return providers.filter(
+ (p) => p.providerType === "llama_cpp" && p.autoReloadModels === true,
+ );
+}
+
+export function startLlamaCppAutoReload(intervalMs = 10_000): () => void {
+ // id -> endpoint + catalog last reloaded (absent: offline); the catalog catches restarts between polls.
+ const online = new Map<string, string>();
+ const inFlight = new Set<string>();
+ let stopped = false;
+ const endpoint = (p: ExternalProviderConfig) => `${p.baseUrl}|${p.hasApiKey === true}`;
+
+ async function probe(provider: ExternalProviderConfig) {
+ inFlight.add(provider.id);
+ try {
+ const listed = await listProviderModels({
+ providerType: "llama_cpp",
+ providerId: provider.id,
+ baseUrl: provider.baseUrl || null,
+ apiKey: provider.hasApiKey ? "" : getExternalProviderApiKey(provider.id),
+ });
+ const catalog = [...new Set(listed.map((m) => m.id.trim()).filter(Boolean))];
+ const key = `${endpoint(provider)}|${catalog.join("\n")}`;
+ // A server still starting can list nothing: keep the last good selection.
+ if (stopped || catalog.length === 0) return;
+ // Skip only while this tab still shows the catalog: a late settings sync can restore older lists.
+ const shown = useExternalProvidersStore.getState().providers.find((p) => p.id === provider.id);
+ if (online.get(provider.id) === key && sameList(catalog, shown?.availableModels ?? [])) return;
+ // Merge against the saved row, not this tab's copy, so tabs agree on what the user picked.
+ const saved = (await listProviderConfigs()).find((c) => c.id === provider.id);
+ const latest = autoReloadConnections().find((p) => p.id === provider.id);
+ if (stopped || !saved || !latest || endpoint(latest) !== endpoint(provider)) return;
+ // Rows saved before model lists reached the backend hold neither: only then trust this tab.
+ const hasSaved =
+ (saved.models?.length ?? 0) > 0 || (saved.available_models?.length ?? 0) > 0;
+ const previousModels = hasSaved ? (saved.models ?? []) : latest.models;
+ const previousCatalog = hasSaved
+ ? (saved.available_models ?? [])
+ : (latest.availableModels ?? []);
+ const models = mergeReloadedModels(previousModels, previousCatalog, catalog);
+ const edited = () => {
+ const row = useExternalProvidersStore.getState().providers.find((p) => p.id === provider.id);
+ return row?.models !== latest.models || row?.availableModels !== latest.availableModels;
+ };
+ // A manual save is in flight or landed since the read: skip, the next probe merges against it.
+ if (providerSavesInFlight.has(provider.id) || edited()) return;
+ if (!sameList(models, previousModels) || !sameList(catalog, previousCatalog)) {
+ await updateProviderConfig(provider.id, { models, availableModels: catalog });
+ }
+ if (stopped) return;
+ if (edited()) return;
+ const { providers, setProviders } = useExternalProvidersStore.getState();
+ const current = providers.find((p) => p.id === provider.id);
+ if (!current) return;
+ if (
+ !sameList(models, current.models) ||
+ !sameList(catalog, current.availableModels ?? [])
+ ) {
+ setProviders(
+ providers.map((p) =>
+ p.id === provider.id ? { ...p, models, availableModels: catalog } : p,
+ ),
+ );
+ }
+ online.set(provider.id, key);
+ } catch {
+ online.delete(provider.id);
+ } finally {
+ inFlight.delete(provider.id);
+ }
+ }
+
+ function probeAll(onlyNew: boolean) {
+ const connections = autoReloadConnections();
+ for (const id of online.keys()) {
+ if (!connections.some((p) => p.id === id)) online.delete(id);
+ }
+ for (const p of connections) {
+ if (inFlight.has(p.id) || (onlyNew && online.has(p.id))) continue;
+ void probe(p);
+ }
+ }
+
+ const unsubscribe = useExternalProvidersStore.subscribe(() => probeAll(true));
+ const timer = setInterval(() => probeAll(false), intervalMs);
+ probeAll(false);
+ return () => {
+ stopped = true;
+ clearInterval(timer);
+ unsubscribe();
+ };
+}
diff --git a/studio/frontend/src/features/chat/stores/external-providers-store.ts b/studio/frontend/src/features/chat/stores/external-providers-store.ts
index 9781d03edca..22accc5a23a 100644
--- a/studio/frontend/src/features/chat/stores/external-providers-store.ts
+++ b/studio/frontend/src/features/chat/stores/external-providers-store.ts
@@ -17,6 +17,9 @@ interface ExternalProvidersState {
setConnectionsEnabled: (enabled: boolean) => void;
}
+/** Connection ids whose settings save is awaiting the backend; auto reload holds its writes. */
+export const providerSavesInFlight = new Set<string>();
+
export const useExternalProvidersStore = create<ExternalProvidersState>(
(set) => ({
providers: loadExternalProviders(),
diff --git a/studio/frontend/src/features/chat/sync-external-providers.ts b/studio/frontend/src/features/chat/sync-external-providers.ts
index 343bb7a5449..ae1a58d6bbb 100644
--- a/studio/frontend/src/features/chat/sync-external-providers.ts
+++ b/studio/frontend/src/features/chat/sync-external-providers.ts
@@ -192,6 +192,8 @@ export function mergeLocalProviderOptions(
isReasoningModel: supportsProviderReasoningToggle(providerType)
? (existing.isReasoningModel ?? synced.isReasoningModel)
: undefined,
+ autoReloadModels:
+ providerType === "llama_cpp" ? existing.autoReloadModels === true : undefined,
openaiContainerTtlMinutes:
providerType === "openai" &&
typeof existing.openaiContainerTtlMinutes === "number" &&
diff --git a/studio/frontend/tests/connected-model-row-actions.test.ts b/studio/frontend/tests/connected-model-row-actions.test.ts
index ff23cfc0c81..59733d1628c 100644
--- a/studio/frontend/tests/connected-model-row-actions.test.ts
+++ b/studio/frontend/tests/connected-model-row-actions.test.ts
@@ -810,3 +810,15 @@ test("a served catalogue cannot take away a context window it has no field for",
setModelsDevCatalog({ fetched_at: Date.now(), providers: {} } as never);
});
+
+test("connection saves write back the live store, not the render snapshot", () => {
+ const liveWrites = providersDialog.match(
+ /onProvidersChange\(\s*\[?\s*(\.\.\.)?useExternalProvidersStore\.getState\(\)\.providers\.(map|filter)\(/g,
+ );
+ assert.equal(liveWrites?.length, 3);
+ assert.match(providersDialog, /models: keepSavedModels \? undefined : modelsToSave,/);
+ assert.match(providersDialog, /availableModels: keepSavedModels \? undefined : availableModelsToSave,/);
+ // An empty response (row never backfilled) keeps this browser's lists instead of blanking them.
+ assert.match(providersDialog, /updated\.models\?\.length \? updated\.models : existing\.models/);
+ assert.match(providersDialog, /updated\.available_models\?\.length\s*\?\s*updated\.available_models\s*:\s*existing\.availableModels/);
+});
diff --git a/studio/frontend/tests/llama-cpp-auto-reload.test.ts b/studio/frontend/tests/llama-cpp-auto-reload.test.ts
new file mode 100644
index 00000000000..9878361e149
--- /dev/null
+++ b/studio/frontend/tests/llama-cpp-auto-reload.test.ts
@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+import { createServer, type ViteDevServer } from "vite";
+
+let vite: ViteDevServer;
+before(async () => {
+ vite = await createServer({
+ appType: "custom",
+ server: { middlewareMode: true, hmr: false },
+ });
+});
+after(async () => {
+ await vite.close();
+});
+
+test("the preference is llama.cpp only and survives a backend sync", async () => {
+ const { mergeLocalProviderOptions } = await vite.ssrLoadModule(
+ "/src/features/chat/sync-external-providers.ts",
+ );
+ const merge = (existing: object | undefined, providerType: string) =>
+ mergeLocalProviderOptions(existing, { providerType }).autoReloadModels;
+ assert.equal(merge(undefined, "llama_cpp"), undefined);
+ assert.equal(merge({ autoReloadModels: true }, "llama_cpp"), true);
+ assert.equal(merge({ autoReloadModels: true }, "ollama"), undefined);
+});
+
+test("a reload keeps manual IDs and picks, drops removed IDs and enables new ones", async () => {
+ const { mergeReloadedModels } = await vite.ssrLoadModule(
+ "/src/features/chat/llama-cpp-auto-reload.ts",
+ );
+ // beta was deselected, alpha is gone, gamma is new, manual was typed in.
+ assert.deepEqual(
+ mergeReloadedModels(["manual", "alpha"], ["alpha", "beta"], ["beta", "gamma"]),
+ ["manual", "gamma"],
+ );
+ assert.deepEqual(
+ mergeReloadedModels(["manual"], [], ["manual", "alpha"]),
+ ["manual", "alpha"],
+ );
+ // Nothing left selected: enable the whole catalog rather than an empty connection.
+ assert.deepEqual(mergeReloadedModels(["alpha"], ["alpha", "beta"], ["beta"]), ["beta"]);
+});
+
+test("the monitor reloads on first contact and each reconnect only", async () => {
+ const storage = new Map<string, string>([["unsloth_auth_token", "t"]]);
+ const saved = { models: ["manual", "alpha"], available_models: ["alpha"] };
+ let served: string[] | null = ["alpha", "beta"];
+ const puts: Array<{ models: string[]; available_models: string[] }> = [];
+ let calls = 0;
+ const originals = [globalThis.window, globalThis.localStorage, globalThis.fetch] as const;
+ Object.defineProperty(globalThis, "window", {
+ configurable: true,
+ value: { addEventListener() {}, removeEventListener() {} },
+ });
+ Object.defineProperty(globalThis, "localStorage", {
+ configurable: true,
+ value: {
+ getItem: (key: string) => storage.get(key) ?? null,
+ setItem: (key: string, value: string) => storage.set(key, value),
+ removeItem: (key: string) => storage.delete(key),
+ },
+ });
+ globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+ calls++;
+ const url = String(input);
+ if (url.includes("/api/providers/models")) {
+ return served === null
+ ? Response.json({ detail: "connection refused" }, { status: 502 })
+ : Response.json(served.map((id) => ({ id })));
+ }
+ if (init?.method === "PUT") {
+ const body = JSON.parse(String(init.body));
+ puts.push(body);
+ Object.assign(saved, body);
+ return Response.json({ id: "p", ...saved });
+ }
+ if (url.replace(/\/$/, "").endsWith("/api/providers")) {
+ return Response.json([{ id: "p", base_url: "http://llama/v1", ...saved }]);
+ }
+ throw new Error(`unexpected ${url}`);
+ }) as typeof fetch;
+
+ const { startLlamaCppAutoReload } = await vite.ssrLoadModule(
+ "/src/features/chat/llama-cpp-auto-reload.ts",
+ );
+ const { providerSavesInFlight, useExternalProvidersStore: store } = await vite.ssrLoadModule(
+ "/src/features/chat/stores/external-providers-store.ts",
+ );
+ store.setState({
+ connectionsEnabled: true,
+ providers: [{
+ id: "p",
+ providerType: "llama_cpp",
+ name: "llama.cpp",
+ baseUrl: "http://llama/v1",
+ models: ["manual", "alpha"],
+ availableModels: ["alpha"],
+ hasApiKey: false,
+ autoReloadModels: true,
+ createdAt: 1,
+ updatedAt: 1,
+ }],
+ });
+ const row = () => store.getState().providers[0];
+ const settle = async (condition: () => boolean) => {
+ for (let i = 0; i < 200 && !condition(); i++) await new Promise((r) => setTimeout(r, 5));
+ assert.ok(condition());
+ };
+ const idle = () => new Promise((r) => setTimeout(r, 60));
+
+ const stop = startLlamaCppAutoReload(10);
+ try {
+ await settle(() => puts.length === 1);
+ assert.deepEqual(puts[0], {
+ models: ["manual", "alpha", "beta"],
+ available_models: ["alpha", "beta"],
+ });
+ await settle(() => row().models.length === 3);
+ await idle();
+ assert.equal(puts.length, 1, "no rewrite while the server stays up");
+ // A late settings sync restores older lists in this tab: the next probe repairs them without a write.
+ store.setState({ providers: [{ ...row(), models: ["manual", "alpha"], availableModels: ["alpha"] }] });
+ await settle(() => row().availableModels?.join() === "alpha,beta");
+ assert.equal(puts.length, 1);
+
+ // Another tab deselected beta; this tab's copy still has it. The reload must follow the saved row.
+ saved.models = ["manual", "alpha"];
+ served = null;
+ await idle();
+ served = ["alpha", "beta", "gamma"];
+ await settle(() => puts.length === 2);
+ assert.deepEqual(puts[1].models, ["manual", "alpha", "gamma"]);
+ await settle(() => row().models.join() === "manual,alpha,gamma");
+
+ served = null;
+ await idle();
+ served = [];
+ await idle();
+ assert.equal(puts.length, 2);
+ served = ["gamma"];
+ await settle(() => puts.length === 3);
+ assert.deepEqual(puts[2].models, ["manual", "gamma"]);
+
+ // A restart inside one poll interval is never seen offline; the changed list alone must reload.
+ served = ["gamma", "delta"];
+ await settle(() => puts.length === 4);
+ assert.deepEqual(puts[3].models, ["manual", "gamma", "delta"]);
+
+ // A manual save in flight holds the reload until it ends, so the save is never overwritten.
+ providerSavesInFlight.add("p");
+ served = ["gamma", "delta", "zeta"];
+ await idle();
+ assert.equal(puts.length, 4);
+ providerSavesInFlight.delete("p");
+ await settle(() => puts.length === 5);
+ assert.deepEqual(puts[4].models, ["manual", "gamma", "delta", "zeta"]);
+
+ // Another tab replaced the IDs by hand and left no catalog: the saved IDs win over this tab's copy.
+ Object.assign(saved, { models: ["typed"], available_models: [] });
+ served = ["gamma", "omega"];
+ await settle(() => puts.length === 6);
+ assert.deepEqual(puts[5].models, ["typed", "gamma", "omega"]);
+
+ store.setState({ providers: [{ ...row(), autoReloadModels: false }] });
+ served = null;
+ await idle();
+ served = ["gamma", "epsilon"];
+ await idle();
+ assert.equal(puts.length, 6);
+ } finally {
+ stop();
+ }
+ const callsAtStop = calls;
+ await idle();
+ assert.equal(calls, callsAtStop, "stopped monitor makes no requests");
+ Object.defineProperty(globalThis, "window", { configurable: true, value: originals[0] });
+ Object.defineProperty(globalThis, "localStorage", { configurable: true, value: originals[1] });
+ globalThis.fetch = originals[2];
+});