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.

Studio: let the API load settings panel forget an entry (#10160)

Nilay2d346cce016a
diff --git a/studio/backend/routes/settings.py b/studio/backend/routes/settings.py
index bcf52bc947e..e109c2fc854 100644
--- a/studio/backend/routes/settings.py
+++ b/studio/backend/routes/settings.py
@@ -861,6 +861,8 @@ class ModelOverridesResponse(BaseModel):
# casefold is not toLowerCase, and an ambiguous fold matches nothing on purpose.
resolved: Optional[dict] = None
resolved_key: Optional[str] = None
+ # What an explicit remove cleared; empty for a save.
+ removed_keys: list[str] = []
def _upload_limit_response(limit_mb: int) -> UploadLimitResponse:
@@ -1723,6 +1725,7 @@ def update_openai_auto_switch_override(
if _kept_tuning[name] is None:
_kept_tuning[name] = _stored_tuning.get(name)
break
+ removed_keys: list[str] = []
if payload.remove is True:
# An explicit remove wins over any other field. Remove the key a load resolves to,
# not the literal one sent (the browser normalizes casing), and every spelling:
@@ -1730,17 +1733,12 @@ def update_openai_auto_switch_override(
target_ids = resolve_model_override_keys(payload.model_id) or [
payload.model_id,
]
- for target_id in target_ids:
- set_model_override(target_id, llama_extra_args = [], max_seq_length = None)
+ removed_keys.extend(target_ids)
# A standalone .gguf is keyed by its bare path now, but a load also reads the
# filename-derived <path>:LABEL an upgraded install holds, which would outlive this.
legacy_id = _legacy_standalone_gguf_key(payload.model_id)
if legacy_id and legacy_id not in target_ids:
- set_model_override(
- legacy_id,
- llama_extra_args = [],
- max_seq_length = None,
- )
+ removed_keys.append(legacy_id)
# The mirror image of the carry-over above: a save under repo:QUANT copies the flags off a legacy bare
# `repo` entry and leaves it in place, and the loader falls back to it when the qualified key misses, so
# clearing only the qualified key hands the same flags straight back and the forget does nothing. Nothing in
@@ -1755,15 +1753,14 @@ def update_openai_auto_switch_override(
target_ids,
)
):
- set_model_override(
- bare_id,
- llama_extra_args = [],
- max_seq_length = None,
- )
+ removed_keys.append(bare_id)
# And the other spelling of a cached repo: the loader reads the load path before
# the advertised id, so clearing only the id leaves the path entry still applying.
for alias_id in cached_repo_alias_keys(payload.model_id):
- set_model_override(alias_id, llama_extra_args = [], max_seq_length = None)
+ if alias_id not in removed_keys:
+ removed_keys.append(alias_id)
+ for removed_id in removed_keys:
+ set_model_override(removed_id, llama_extra_args = [], max_seq_length = None)
else:
# Save under the key a load resolves to, as the removal branch does: the literal
# id would leave two keys for one model, making every other casing ambiguous.
@@ -1818,7 +1815,7 @@ def update_openai_auto_switch_override(
event = "settings.update_model_override_failed",
log = logger,
) from exc
- return ModelOverridesResponse(overrides = get_model_overrides())
+ return ModelOverridesResponse(overrides = get_model_overrides(), removed_keys = removed_keys)
class EmbeddingModelPayload(BaseModel):
diff --git a/studio/backend/tests/test_openai_auto_switch.py b/studio/backend/tests/test_openai_auto_switch.py
index a822e5653a0..7dc7bc21432 100644
--- a/studio/backend/tests/test_openai_auto_switch.py
+++ b/studio/backend/tests/test_openai_auto_switch.py
@@ -6691,6 +6691,54 @@ def test_forgetting_a_cached_repo_also_clears_its_snapshot_path_entry(override_s
assert resp.overrides == {}
+def test_a_remove_reports_every_key_it_cleared(override_store):
+ settings.set_model_override("unsloth/B-GGUF", max_seq_length = 2048)
+ settings.set_model_override("unsloth/B-GGUF:Q4_K_M", max_seq_length = 32768)
+ settings.set_model_override(f"{_LEGACY_SNAPSHOT}:Q4_K_M", max_seq_length = 4096)
+
+ resp = _put("unsloth/B-GGUF:Q4_K_M", remove = True, llama_extra_args = [])
+ assert resp.removed_keys == [
+ "unsloth/B-GGUF:Q4_K_M",
+ "unsloth/B-GGUF",
+ f"{_LEGACY_SNAPSHOT}:Q4_K_M",
+ ]
+ assert resp.overrides == {}
+
+
+def test_a_remove_reports_the_legacy_label_of_a_loose_gguf(override_store):
+ settings.set_model_override("/models/Qwen3-4B-Q4_K_M.gguf:q4_k_m", max_seq_length = 4096)
+
+ resp = _put("/models/Qwen3-4B-Q4_K_M.gguf", remove = True, llama_extra_args = [])
+ assert resp.removed_keys == [
+ "/models/Qwen3-4B-Q4_K_M.gguf",
+ "/models/Qwen3-4B-Q4_K_M.gguf:q4_k_m",
+ ]
+ assert resp.overrides == {}
+
+
+def test_a_remove_leaves_the_bare_row_for_a_remaining_quant_and_says_so(override_store):
+ settings.set_model_override("unsloth/B-GGUF", max_seq_length = 2048)
+ settings.set_model_override("unsloth/B-GGUF:Q4_K_M", max_seq_length = 32768)
+ settings.set_model_override("unsloth/B-GGUF:Q8_0", max_seq_length = 16384)
+
+ resp = _put("unsloth/B-GGUF:Q4_K_M", remove = True, llama_extra_args = [])
+ assert resp.removed_keys == ["unsloth/B-GGUF:Q4_K_M"]
+ assert set(resp.overrides) == {"unsloth/B-GGUF", "unsloth/B-GGUF:Q8_0"}
+
+
+def test_a_save_reports_no_removed_keys(override_store):
+ resp = _put("unsloth/B-GGUF:Q4_K_M", max_seq_length = 8192)
+ assert resp.removed_keys == []
+
+
+def test_a_fill_reports_no_removed_keys(override_store):
+ # A fill retires nothing, and the browser deletes whatever a response reports.
+ settings.set_model_override(f"{_LEGACY_SNAPSHOT}:Q4_K_M", max_seq_length = 4096)
+
+ resp = _put("unsloth/B-GGUF:Q4_K_M", max_seq_length = 32768, fill_absent_fields = True)
+ assert resp.removed_keys == []
+
+
def test_retiring_a_spelling_leaves_every_other_entry_alone(override_store):
# Only the same repo and the same quant fold together: a ./models path is keyed by its path
# alone, another quant has its own settings, and a bare entry backs every quant.
diff --git a/studio/frontend/src/features/api-monitor/components/saved-model-settings.tsx b/studio/frontend/src/features/api-monitor/components/saved-model-settings.tsx
index 76d094d90cc..e897a04cbaa 100644
--- a/studio/frontend/src/features/api-monitor/components/saved-model-settings.tsx
+++ b/studio/frontend/src/features/api-monitor/components/saved-model-settings.tsx
@@ -1,16 +1,32 @@
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
-// What a remote load will apply, otherwise unanswerable from outside the process. Read
-// only: the model's settings page is the only place that owns this and the local store.
+// What a remote load will apply, otherwise unanswerable from outside the process.
+import { Button } from "@/components/ui/button";
import { Skeleton } from "@/components/ui/skeleton";
+import { Spinner } from "@/components/ui/spinner";
import {
type ApiModelOverride,
type ApiModelOverrides,
fetchModelOverrides,
+ putModelOverride,
} from "@/features/model-picker/api/model-overrides";
-import { type ReactElement, useCallback, useEffect, useState } from "react";
+import { deletePerModelConfigsForOverrideKeys } from "@/features/model-picker/model-config/per-model-config";
+import { Trash2 } from "lucide-react";
+import {
+ type ReactElement,
+ useCallback,
+ useEffect,
+ useRef,
+ useState,
+} from "react";
+import { toast } from "sonner";
+import { forgetModelOverride } from "../forget-model-override";
+
+function plural(count: number, noun: string): string {
+ return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
/** Summary of the fields the loader will apply, in load order. */
function describeOverride(override: ApiModelOverride): string[] {
@@ -32,7 +48,7 @@ function describeOverride(override: ApiModelOverride): string[] {
);
}
if (override.n_parallel) {
- parts.push(`${override.n_parallel} parallel slots`);
+ parts.push(plural(override.n_parallel, "parallel slot"));
}
if (override.n_batch) {
parts.push(`batch ${override.n_batch}`);
@@ -50,7 +66,7 @@ function describeOverride(override: ApiModelOverride): string[] {
// user can pick for either (no checkpoints, no host cache) and would otherwise
// be listed as unset.
if (override.ctx_checkpoints !== undefined) {
- parts.push(`${override.ctx_checkpoints} checkpoints`);
+ parts.push(plural(override.ctx_checkpoints, "checkpoint"));
}
if (override.cache_ram !== undefined) {
parts.push(`cache RAM ${override.cache_ram} MiB`);
@@ -65,10 +81,10 @@ function describeOverride(override: ApiModelOverride): string[] {
parts.push("manual GPU memory");
}
if (override.gpu_layers != null) {
- parts.push(`${override.gpu_layers} GPU layers`);
+ parts.push(plural(override.gpu_layers, "GPU layer"));
}
if (override.n_cpu_moe) {
- parts.push(`${override.n_cpu_moe} MoE layers on CPU`);
+ parts.push(`${plural(override.n_cpu_moe, "MoE layer")} on CPU`);
}
if (override.gpu_ids?.length) {
parts.push(`GPU ${override.gpu_ids.join(", ")}`);
@@ -85,12 +101,28 @@ function describeOverride(override: ApiModelOverride): string[] {
export function SavedModelSettingsPanel(): ReactElement {
const [overrides, setOverrides] = useState<ApiModelOverrides | null>(null);
const [error, setError] = useState<string | null>(null);
+ const [forgetting, setForgetting] = useState<ReadonlySet<string>>(
+ () => new Set(),
+ );
+ // Each forget refetches, and a row disables only its own button, so two of them
+ // overlap. The reads answer in whatever order the network gives, and the older one
+ // saw the row the newer forget removed: last issued has to win, or a row the server
+ // no longer holds is painted back and stays until the panel remounts.
+ const loadSeq = useRef(0);
const load = useCallback(async () => {
+ const seq = ++loadSeq.current;
try {
- setOverrides(await fetchModelOverrides());
+ const next = await fetchModelOverrides();
+ if (seq !== loadSeq.current) {
+ return;
+ }
+ setOverrides(next);
setError(null);
} catch (err: unknown) {
+ if (seq !== loadSeq.current) {
+ return;
+ }
setError(
err instanceof Error
? err.message
@@ -103,6 +135,31 @@ export function SavedModelSettingsPanel(): ReactElement {
void load();
}, [load]);
+ const forget = useCallback(
+ async (overrideKey: string) => {
+ setForgetting((prev) => new Set(prev).add(overrideKey));
+ try {
+ await forgetModelOverride(overrideKey, {
+ listedKeys: Object.keys(overrides ?? {}),
+ removeRemote: (modelId, ggufVariant) =>
+ putModelOverride(modelId, ggufVariant, null),
+ removeLocal: deletePerModelConfigsForOverrideKeys,
+ reload: load,
+ onError: (message) => {
+ toast.error(message);
+ },
+ });
+ } finally {
+ setForgetting((prev) => {
+ const next = new Set(prev);
+ next.delete(overrideKey);
+ return next;
+ });
+ }
+ },
+ [load, overrides],
+ );
+
const entries = Object.entries(overrides ?? {});
return (
@@ -114,9 +171,9 @@ export function SavedModelSettingsPanel(): ReactElement {
<p className="text-sm text-muted-foreground">
When a request names one of these models, Unsloth loads it with these
settings, the same ones you saved in the model&apos;s settings page.
- Models without an entry load with app defaults. Edit or forget an
- entry from that model&apos;s settings, which keeps this list and the
- picker in step.
+ Models without an entry load with app defaults. Edit an entry from
+ that model&apos;s settings, or forget it here, which clears it from
+ the picker too.
</p>
</div>
@@ -153,6 +210,21 @@ export function SavedModelSettingsPanel(): ReactElement {
{summary.length > 0 ? summary.join(" · ") : "App defaults"}
</span>
</div>
+ <Button
+ variant="ghost"
+ size="icon-sm"
+ className="shrink-0 text-muted-foreground hover:text-destructive"
+ aria-label={`Forget settings for ${modelId}`}
+ title="Forget these settings"
+ disabled={forgetting.has(modelId)}
+ onClick={() => void forget(modelId)}
+ >
+ {forgetting.has(modelId) ? (
+ <Spinner label="Forgetting" />
+ ) : (
+ <Trash2 />
+ )}
+ </Button>
</li>
);
})}
diff --git a/studio/frontend/src/features/api-monitor/forget-model-override.ts b/studio/frontend/src/features/api-monitor/forget-model-override.ts
new file mode 100644
index 00000000000..e0abd5b7543
--- /dev/null
+++ b/studio/frontend/src/features/api-monitor/forget-model-override.ts
@@ -0,0 +1,58 @@
+// 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 { foldOverrideKey } from "@/features/model-picker/api/model-overrides";
+import { splitModelOverrideKey } from "@/features/model-picker/model-config/model-identity";
+
+export type ForgetModelOverrideDeps = {
+ listedKeys: readonly string[];
+ removeRemote: (
+ modelId: string,
+ ggufVariant: string | null,
+ ) => Promise<{
+ overrides: Readonly<Record<string, unknown>>;
+ removedKeys: readonly string[];
+ }>;
+ /** False when a record was left behind. */
+ removeLocal: (overrideKeys: readonly string[]) => boolean;
+ reload: () => Promise<void>;
+ onError: (message: string) => void;
+};
+
+export const FORGET_MODEL_OVERRIDE_FAILED = "Failed to forget these settings";
+export const FORGET_MODEL_OVERRIDE_LOCAL_FAILED =
+ "Forgot these settings for the API, but this browser kept its own copy";
+
+function keysNoLongerHeld(
+ listedKeys: readonly string[],
+ overrides: Readonly<Record<string, unknown>>,
+): string[] {
+ const held = new Set(Object.keys(overrides).map(foldOverrideKey));
+ return listedKeys.filter((key) => !held.has(foldOverrideKey(key)));
+}
+
+export async function forgetModelOverride(
+ overrideKey: string,
+ deps: ForgetModelOverrideDeps,
+): Promise<void> {
+ const [modelId, ggufVariant] = splitModelOverrideKey(overrideKey);
+ let result: Awaited<ReturnType<ForgetModelOverrideDeps["removeRemote"]>>;
+ try {
+ result = await deps.removeRemote(modelId, ggufVariant);
+ } catch (err: unknown) {
+ deps.onError(
+ err instanceof Error ? err.message : FORGET_MODEL_OVERRIDE_FAILED,
+ );
+ return;
+ }
+ // A backend that predates removed_keys is read off the map it returns. A copy left
+ // here is reported, not swallowed: the picker applies it and the next save mirrors it.
+ const cleared =
+ result.removedKeys.length > 0
+ ? result.removedKeys
+ : keysNoLongerHeld(deps.listedKeys, result.overrides);
+ if (!deps.removeLocal([...new Set([overrideKey, ...cleared])])) {
+ deps.onError(FORGET_MODEL_OVERRIDE_LOCAL_FAILED);
+ }
+ await deps.reload();
+}
diff --git a/studio/frontend/src/features/model-picker/api/model-overrides.ts b/studio/frontend/src/features/model-picker/api/model-overrides.ts
index b19d2b67914..aee92e2fe48 100644
--- a/studio/frontend/src/features/model-picker/api/model-overrides.ts
+++ b/studio/frontend/src/features/model-picker/api/model-overrides.ts
@@ -15,6 +15,7 @@ import {
import {
DEFAULT_PER_MODEL_CONFIG,
type PerModelConfig,
+ deletePerModelConfigsForOverrideKeys,
normalizePerModelConfig,
} from "../model-config/per-model-config";
@@ -112,7 +113,7 @@ function foldCaseInsensitivePath(key: string): string | null {
return trimmed.toLowerCase();
}
-function foldOverrideKey(key: string): string {
+export function foldOverrideKey(key: string): string {
// A path that folds does so whole, separators and casing together.
const path = foldCaseInsensitivePath(key);
if (path !== null) {
@@ -469,7 +470,13 @@ export function toApiOverride(config: PerModelConfig | null): ApiModelOverride {
// One in-flight write per model, so writes commit in issue order: otherwise the older
// response can land last and resurrect the entry the newer one replaced. Models overlap.
-const writesByKey = new Map<string, Promise<void>>();
+const writesByKey = new Map<string, Promise<ModelOverrideWriteResult>>();
+
+export interface ModelOverrideWriteResult {
+ overrides: ApiModelOverrides;
+ /** Empty for a save, and from a backend that predates the field. */
+ removedKeys: string[];
+}
export interface PutModelOverrideOptions {
/**
@@ -491,7 +498,7 @@ export async function putModelOverride(
ggufVariant: string | null | undefined,
config: PerModelConfig | null,
options?: PutModelOverrideOptions,
-): Promise<void> {
+): Promise<ModelOverrideWriteResult> {
// Keyed by the folded identity: the backend resolves a legacy casing and the
// normalized one to one row, so raw strings would open two queues and race again.
const key = modelOverrideKey(
@@ -505,7 +512,7 @@ export async function putModelOverride(
.then(() => sendModelOverride(modelId, ggufVariant, config, options));
writesByKey.set(key, write);
try {
- await write;
+ return await write;
} finally {
// Only the last writer clears the slot, so a queue still building keeps order.
if (writesByKey.get(key) === write) {
@@ -519,7 +526,7 @@ async function sendModelOverride(
ggufVariant: string | null | undefined,
config: PerModelConfig | null,
options?: PutModelOverrideOptions,
-): Promise<void> {
+): Promise<ModelOverrideWriteResult> {
const res = await authFetch(OVERRIDES_URL, {
method: "PUT",
headers: { "Content-Type": "application/json" },
@@ -556,12 +563,27 @@ async function sendModelOverride(
await readFastApiError(res, "Failed to save model settings for the API"),
);
}
+ const body = (await res.json()) as {
+ overrides?: ApiModelOverrides;
+ // biome-ignore lint/style/useNamingConvention: API schema
+ removed_keys?: unknown;
+ };
+ return {
+ overrides: body.overrides ?? {},
+ removedKeys: Array.isArray(body.removed_keys)
+ ? body.removed_keys.filter(
+ (key): key is string => typeof key === "string",
+ )
+ : [],
+ };
}
/**
* Mirror a per-model config save to the backend without blocking the UI. Best-effort: the
* localStorage write already happened, so a failed sync must not fail the save. Logged, not
* toasted: an API load falls back to defaults until the next save.
+ *
+ * A forget also drops the local records for every spelling the server reports clearing.
*/
export function syncModelOverride(
modelId: string,
@@ -569,12 +591,18 @@ export function syncModelOverride(
config: PerModelConfig | null,
options?: PutModelOverrideOptions,
): void {
- void putModelOverride(modelId, ggufVariant, config, options).catch(
- (error: unknown) => {
+ void putModelOverride(modelId, ggufVariant, config, options)
+ .then(({ removedKeys }) => {
+ if (!deletePerModelConfigsForOverrideKeys(removedKeys)) {
+ console.warn(
+ "Forgot model settings on the server, but this browser kept its own copy.",
+ );
+ }
+ })
+ .catch((error: unknown) => {
console.warn(
"Failed to mirror model settings to the server; an API load of this model will use defaults.",
error,
);
- },
- );
+ });
}
diff --git a/studio/frontend/src/features/model-picker/components/model-config-page.tsx b/studio/frontend/src/features/model-picker/components/model-config-page.tsx
index 8f1f6dd968d..6b91524d263 100644
--- a/studio/frontend/src/features/model-picker/components/model-config-page.tsx
+++ b/studio/frontend/src/features/model-picker/components/model-config-page.tsx
@@ -3135,6 +3135,7 @@ export function ModelConfigPage({
// Mirror to the server so an API load gets these settings, not app defaults. Best-effort, and
// skipped when the localStorage write failed or the two would permanently disagree. Gated on
// auto-switch reach, not GGUF-ness: the resolver skips Ollama, and a native-path lease is the same.
+ // A forget also drops the local records for every other spelling the server reports clearing.
if (
!saveFailed &&
(target.apiLoadable ?? target.isGguf) &&
diff --git a/studio/frontend/src/features/model-picker/model-config/model-identity.ts b/studio/frontend/src/features/model-picker/model-config/model-identity.ts
index d07eb72dff2..4a8f9c580bd 100644
--- a/studio/frontend/src/features/model-picker/model-config/model-identity.ts
+++ b/studio/frontend/src/features/model-picker/model-config/model-identity.ts
@@ -6,6 +6,7 @@ import {
normalizeGgufVariantIdentity,
normalizeModelIdentity,
} from "@/features/hub/lib/model-identity";
+import { looksLikeLocalPath } from "@/lib/local-path";
// eslint-disable-next-line no-restricted-imports -- Avoid the hub barrel's React and download-manager exports.
export {
@@ -150,3 +151,29 @@ export function splitQuantSuffix(value: string): [string, string] | null {
? [head, tail]
: null;
}
+
+/**
+* `[modelId, variant]` for an override key, or `[value, null]` when it names no variant.
+*
+* splitQuantSuffix answers for a bare quant token, which is what a stored key usually spells.
+* A qualified variant is not one: it can name a directory (`distilled/model-Q6_K`) or a whole
+* filename stem, and both are refused there. A repo id carries no colon, so for anything that
+* is not a local path the last colon is the separator whatever the tail spells. A path is left
+* whole for the reason the backend's resolver leaves it whole: a colon is legal in a POSIX
+* filename, so "/models/foo:bar/baz.gguf" is one name and splitting it would answer for a
+* different model. */
+export function splitModelOverrideKey(value: string): [string, string | null] {
+ const quant = splitQuantSuffix(value);
+ if (quant) {
+ return quant;
+ }
+ const separator = value.lastIndexOf(":");
+ if (
+ separator <= 0 ||
+ separator === value.length - 1 ||
+ looksLikeLocalPath(value)
+ ) {
+ return [value, null];
+ }
+ return [value.slice(0, separator), value.slice(separator + 1)];
+}
diff --git a/studio/frontend/src/features/model-picker/model-config/per-model-config.ts b/studio/frontend/src/features/model-picker/model-config/per-model-config.ts
index e19938dac94..ec0dd05cbeb 100644
--- a/studio/frontend/src/features/model-picker/model-config/per-model-config.ts
+++ b/studio/frontend/src/features/model-picker/model-config/per-model-config.ts
@@ -1318,6 +1318,60 @@ export function deletePerModelConfig(
return writeMap(map);
}
+/**
+ * Every stored record an override key names. Matched, not split: a colon is legal in
+ * a path, and two records can spell one key.
+ */
+function findModelOverrideKeyOwners(
+ overrideKey: string,
+): { modelId: string; ggufVariant: string | null }[] {
+ const key = overrideKey.trim();
+ const foldedKey = normalizeModelIdentity(key);
+ const owners: { modelId: string; ggufVariant: string | null }[] = [];
+ for (const storageKey of Object.keys(readMap())) {
+ const modelId = modelIdFromStorageKey(storageKey);
+ if (!modelId) {
+ continue;
+ }
+ // Already lowercased by modelStorageKey, which is why only the tail folds below.
+ const variant = normalizeGgufVariantIdentity(
+ ggufVariantFromStorageKey(storageKey),
+ );
+ if (!variant) {
+ if (foldedKey === normalizeModelIdentity(modelId)) {
+ owners.push({ modelId, ggufVariant: null });
+ }
+ continue;
+ }
+ const cut = key.length - variant.length - 1;
+ if (
+ cut > 0 &&
+ key[cut] === ":" &&
+ key.slice(cut + 1).toLowerCase() === variant &&
+ normalizeModelIdentity(key.slice(0, cut)) ===
+ normalizeModelIdentity(modelId)
+ ) {
+ owners.push({ modelId, ggufVariant: variant });
+ }
+ }
+ return owners;
+}
+
+/** Delete the records the server keys name; false when one was left behind. */
+export function deletePerModelConfigsForOverrideKeys(
+ overrideKeys: readonly string[],
+): boolean {
+ let deleted = true;
+ for (const overrideKey of overrideKeys) {
+ for (const owner of findModelOverrideKeyOwners(overrideKey)) {
+ if (!deletePerModelConfig(owner.modelId, owner.ggufVariant)) {
+ deleted = false;
+ }
+ }
+ }
+ return deleted;
+}
+
/**
* Move a saved config from an id an older release keyed it by onto the current one.
*
diff --git a/studio/frontend/tests/api-load-settings-refetch-sequencing.test.ts b/studio/frontend/tests/api-load-settings-refetch-sequencing.test.ts
new file mode 100644
index 00000000000..d9ef78135ec
--- /dev/null
+++ b/studio/frontend/tests/api-load-settings-refetch-sequencing.test.ts
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+// A row's forget button disables only that row, so two forgets overlap, and each one
+// refetches the whole map when it lands. The two GETs read the server at different
+// moments and answer in whatever order the network gives: the earlier read still holds
+// the row the later forget removed, so if it paints last the panel shows an entry the
+// server no longer has, and it stays there until the panel remounts. Last issued wins.
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const SOURCE = readFileSync(
+ fileURLToPath(
+ new URL(
+ "../src/features/api-monitor/components/saved-model-settings.tsx",
+ import.meta.url,
+ ),
+ ),
+ "utf8",
+);
+
+const LOAD = SOURCE.slice(
+ SOURCE.indexOf("const load = useCallback("),
+ SOURCE.indexOf("useEffect(() => {"),
+);
+
+test("every refetch takes a sequence number", () => {
+ assert.match(SOURCE, /const loadSeq = useRef\(0\);/);
+ assert.match(LOAD, /const seq = \+\+loadSeq\.current;/);
+});
+
+test("a superseded refetch paints no rows", () => {
+ const guard = LOAD.slice(0, LOAD.indexOf("setOverrides("));
+ assert.match(
+ guard,
+ /if \(seq !== loadSeq\.current\) \{\s*return;\s*\}/,
+ "the check must sit between the await and the row write",
+ );
+ // Read into a local first, or the guard runs before the response exists.
+ assert.match(LOAD, /const next = await fetchModelOverrides\(\);/);
+});
+
+// The old-backend fallback diffs these keys against the returned map; [] would disable it.
+test("a forget hands the panel's listed keys to the fallback", () => {
+ const forget = SOURCE.slice(
+ SOURCE.indexOf("const forget = useCallback("),
+ SOURCE.indexOf("const entries = "),
+ );
+ assert.match(forget, /listedKeys: Object\.keys\(overrides \?\? \{\}\),/);
+ assert.match(forget, /\[load, overrides\],\s*\);\s*$/);
+});
+
+test("a superseded refetch does not report its failure either", () => {
+ const catchBlock = LOAD.slice(LOAD.indexOf("} catch (err: unknown) {"));
+ assert.match(catchBlock, /if \(seq !== loadSeq\.current\) \{\s*return;\s*\}/);
+ assert.ok(
+ catchBlock.indexOf("loadSeq.current") < catchBlock.indexOf("setError("),
+ "the guard must precede the error write",
+ );
+});
diff --git a/studio/frontend/tests/api-monitor-forget-model-override.test.ts b/studio/frontend/tests/api-monitor-forget-model-override.test.ts
new file mode 100644
index 00000000000..ea1254d3bd6
--- /dev/null
+++ b/studio/frontend/tests/api-monitor-forget-model-override.test.ts
@@ -0,0 +1,485 @@
+// 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 test from "node:test";
+
+import {
+ installLocalStorageFake,
+ registerStoreStubResolver,
+} from "./helpers/kit.ts";
+
+registerStoreStubResolver();
+const { store } = installLocalStorageFake();
+
+const {
+ FORGET_MODEL_OVERRIDE_FAILED,
+ FORGET_MODEL_OVERRIDE_LOCAL_FAILED,
+ forgetModelOverride,
+} = await import("../src/features/api-monitor/forget-model-override.ts");
+const { putModelOverride, syncModelOverride } = await import(
+ "../src/features/model-picker/api/model-overrides.ts"
+);
+const {
+ DEFAULT_PER_MODEL_CONFIG,
+ PER_MODEL_CONFIG_STORAGE_KEY,
+ deletePerModelConfigsForOverrideKeys,
+ listPerModelConfigs,
+ resolveInitialConfig,
+ savePerModelConfig,
+} = await import(
+ "../src/features/model-picker/model-config/per-model-config.ts"
+);
+const { modelStorageKey } = await import(
+ "../src/features/model-picker/model-config/model-identity.ts"
+);
+const { setAuthFetchHandler } = await import("./helpers/store-stubs/auth.ts");
+
+type Trace = {
+ deps: Parameters<typeof forgetModelOverride>[1];
+ removedRemote: [string, string | null][];
+ removedLocal: (readonly string[])[];
+ errors: string[];
+ reloads: number;
+ sequence: string[];
+};
+
+type Answer = {
+ overrides: Readonly<Record<string, unknown>>;
+ removedKeys: readonly string[];
+};
+
+function answer(removedKeys: readonly string[] = []): Answer {
+ return { overrides: {}, removedKeys };
+}
+
+function trace(
+ remote: () => Promise<Answer> = () => Promise.resolve(answer()),
+ local = true,
+ listedKeys: readonly string[] = [],
+): Trace {
+ const state: Trace = {
+ removedRemote: [],
+ removedLocal: [],
+ errors: [],
+ reloads: 0,
+ sequence: [],
+ deps: {
+ listedKeys,
+ removeRemote: (modelId, ggufVariant) => {
+ state.sequence.push("remote");
+ state.removedRemote.push([modelId, ggufVariant]);
+ return remote();
+ },
+ removeLocal: (overrideKeys) => {
+ state.sequence.push("local");
+ state.removedLocal.push(overrideKeys);
+ return local;
+ },
+ reload: () => {
+ state.sequence.push("reload");
+ state.reloads += 1;
+ return Promise.resolve();
+ },
+ onError: (message) => {
+ state.errors.push(message);
+ },
+ },
+ };
+ return state;
+}
+
+const PATH_ID = "/home/santiago/Temp-GGUF/qwen38/UD-IQ3_XXS";
+const PATH_KEY = `${PATH_ID}:UD-IQ3_XXS`;
+
+test("a forget clears the server entry, then every record it reports, then refetches", async () => {
+ // A listed key that left the map for another reason is not read as forgotten once it reports.
+ const state = trace(
+ () => Promise.resolve(answer([PATH_KEY, PATH_ID])),
+ true,
+ [PATH_KEY, "unsloth/Other-GGUF:Q8_0"],
+ );
+
+ await forgetModelOverride(PATH_KEY, state.deps);
+
+ assert.deepEqual(state.removedRemote, [[PATH_ID, "UD-IQ3_XXS"]]);
+ assert.deepEqual(state.removedLocal, [[PATH_KEY, PATH_ID]]);
+ assert.deepEqual(state.sequence, ["remote", "local", "reload"]);
+ assert.deepEqual(state.errors, []);
+});
+
+test("a server that reports nothing still forgets the clicked key here", async () => {
+ const state = trace();
+
+ await forgetModelOverride(PATH_KEY, state.deps);
+
+ assert.deepEqual(state.removedLocal, [[PATH_KEY]]);
+});
+
+// Without this an old backend leaves the snapshot record, and the next load applies it.
+test("a server that reports nothing is read off the map it returns", async () => {
+ const repoKey = "unsloth/Repo-GGUF:Q4_K_M";
+ const snapshotKey =
+ "/home/u/.cache/hub/models--unsloth--Repo-GGUF/snapshots/2f1c9ab:Q4_K_M";
+ const state = trace(
+ () =>
+ Promise.resolve({
+ overrides: { "unsloth/Other-GGUF:Q8_0": {} },
+ removedKeys: [],
+ }),
+ true,
+ [repoKey, snapshotKey, "unsloth/Other-GGUF:Q8_0"],
+ );
+
+ await forgetModelOverride(repoKey, state.deps);
+
+ assert.deepEqual(state.removedLocal, [[repoKey, snapshotKey]]);
+});
+
+// Another client re-saved the row under the server's casing mid-forget; it is still held.
+test("a listed key the map still holds under another spelling is not read as cleared", async () => {
+ const state = trace(
+ () =>
+ Promise.resolve({
+ overrides: { "unsloth/b-gguf:q8_0": {} },
+ removedKeys: [],
+ }),
+ true,
+ [PATH_KEY, "Unsloth/B-GGUF:Q8_0"],
+ );
+
+ await forgetModelOverride(PATH_KEY, state.deps);
+
+ assert.deepEqual(state.removedLocal, [[PATH_KEY]]);
+});
+
+test("a key with no quant suffix forgets the whole id", async () => {
+ const state = trace();
+
+ await forgetModelOverride("unsloth/Qwen3-4B-GGUF", state.deps);
+
+ assert.deepEqual(state.removedRemote, [["unsloth/Qwen3-4B-GGUF", null]]);
+});
+
+test("a refused remove leaves this browser's copy and the list alone", async () => {
+ const state = trace(() =>
+ Promise.reject(new Error("Settings are read-only")),
+ );
+
+ await assert.doesNotReject(() => forgetModelOverride(PATH_KEY, state.deps));
+
+ assert.deepEqual(state.errors, ["Settings are read-only"]);
+ assert.deepEqual(state.removedLocal, []);
+ assert.equal(state.reloads, 0);
+});
+
+test("a rejection that is not an Error still reports", async () => {
+ const state = trace(() => Promise.reject("offline"));
+
+ await forgetModelOverride(PATH_KEY, state.deps);
+
+ assert.deepEqual(state.errors, [FORGET_MODEL_OVERRIDE_FAILED]);
+ assert.deepEqual(state.removedLocal, []);
+});
+
+test("a browser copy that could not be deleted is reported, not swallowed", async () => {
+ const state = trace(() => Promise.resolve(answer([PATH_KEY])), false);
+
+ await forgetModelOverride(PATH_KEY, state.deps);
+
+ assert.deepEqual(state.errors, [FORGET_MODEL_OVERRIDE_LOCAL_FAILED]);
+ // The server entry is gone whatever the browser did, so the list still refetches.
+ assert.equal(state.reloads, 1);
+});
+
+// A quant can name a directory or a whole filename stem (is_qualified_gguf_variant_key in
+// hub/utils/gguf.py); the key still joins on one colon.
+test("a path-qualified variant splits off the repo it belongs to", async () => {
+ const state = trace();
+
+ await forgetModelOverride(
+ "unsloth/Repo-GGUF:distilled/model-Q6_K",
+ state.deps,
+ );
+
+ assert.deepEqual(state.removedRemote, [
+ ["unsloth/Repo-GGUF", "distilled/model-Q6_K"],
+ ]);
+});
+
+test("a filename-stem variant splits off the repo too", async () => {
+ const state = trace();
+
+ await forgetModelOverride(
+ "unsloth/H3-GGUF:minimax_h3_ref2va_pruned-Q6_K",
+ state.deps,
+ );
+
+ assert.deepEqual(state.removedRemote, [
+ ["unsloth/H3-GGUF", "minimax_h3_ref2va_pruned-Q6_K"],
+ ]);
+});
+
+test("a colon inside a local path is part of the name, not a separator", async () => {
+ const state = trace();
+
+ await forgetModelOverride("/home/u/models/foo:bar/baz.gguf", state.deps);
+
+ assert.deepEqual(state.removedRemote, [
+ ["/home/u/models/foo:bar/baz.gguf", null],
+ ]);
+});
+
+const REPO_ID = "unsloth/Repo-GGUF";
+const SNAPSHOT_PATH =
+ "/home/u/.cache/huggingface/hub/models--unsloth--Repo-GGUF/snapshots/2f1c9ab";
+const OTHER_PATH = "/home/u/models/Repo-Q4_K_M.gguf";
+const QUANT = "Q4_K_M";
+const SAVED = config(32768);
+
+function config(maxSeqLength: number) {
+ return { ...DEFAULT_PER_MODEL_CONFIG, maxSeqLength };
+}
+
+function respond(status: number, body: unknown): void {
+ setAuthFetchHandler(
+ () =>
+ new Response(JSON.stringify(body), {
+ status,
+ headers: { "content-type": "application/json" },
+ }),
+ );
+}
+
+// The local half of a forget: the records this browser drops for the keys a server reports.
+
+test("every reported key's record goes, whichever spelling it uses", () => {
+ store.clear();
+ savePerModelConfig(REPO_ID, QUANT, config(32768));
+ savePerModelConfig(SNAPSHOT_PATH, QUANT, config(4096));
+ savePerModelConfig(REPO_ID, null, config(2048));
+
+ assert.equal(
+ deletePerModelConfigsForOverrideKeys([
+ `${REPO_ID}:${QUANT}`,
+ REPO_ID,
+ `${SNAPSHOT_PATH}:${QUANT}`,
+ ]),
+ true,
+ );
+
+ assert.equal(listPerModelConfigs().length, 0);
+});
+
+test("records the server did not report stay", () => {
+ store.clear();
+ savePerModelConfig(REPO_ID, QUANT, config(32768));
+ savePerModelConfig(REPO_ID, "Q8_0", config(16384));
+ savePerModelConfig(OTHER_PATH, QUANT, config(4096));
+
+ assert.equal(
+ deletePerModelConfigsForOverrideKeys([`${REPO_ID}:${QUANT}`]),
+ true,
+ );
+
+ assert.equal(resolveInitialConfig(REPO_ID, QUANT).remembered, false);
+ assert.equal(resolveInitialConfig(REPO_ID, "Q8_0").remembered, true);
+ assert.equal(resolveInitialConfig(OTHER_PATH, QUANT).remembered, true);
+});
+
+test("the server row's casing still finds the lowercased record", () => {
+ store.clear();
+ savePerModelConfig(REPO_ID, QUANT, config(32768));
+
+ assert.equal(
+ deletePerModelConfigsForOverrideKeys([`${REPO_ID}:q4_k_m`]),
+ true,
+ );
+
+ assert.equal(resolveInitialConfig(REPO_ID, QUANT).remembered, false);
+});
+
+// A colon is legal in a POSIX filename, so the key cannot be parsed apart.
+test("a directory-qualified variant under a path resolves to its stored record", () => {
+ store.clear();
+ savePerModelConfig(
+ "/home/u/models/repo",
+ "distilled/model-Q6_K",
+ config(32768),
+ );
+
+ assert.equal(
+ deletePerModelConfigsForOverrideKeys([
+ "/home/u/models/repo:distilled/model-Q6_K",
+ ]),
+ true,
+ );
+
+ assert.equal(
+ resolveInitialConfig("/home/u/models/repo", "distilled/model-Q6_K")
+ .remembered,
+ false,
+ );
+});
+
+test("two records that spell the same key both go", () => {
+ store.clear();
+ savePerModelConfig(
+ "/home/u/models/repo",
+ "distilled/model-Q6_K",
+ config(32768),
+ );
+ savePerModelConfig(
+ "/home/u/models/repo:distilled/model-Q6_K",
+ null,
+ config(4096),
+ );
+
+ assert.equal(
+ deletePerModelConfigsForOverrideKeys([
+ "/home/u/models/repo:distilled/model-Q6_K",
+ ]),
+ true,
+ );
+
+ assert.equal(listPerModelConfigs().length, 0);
+});
+
+test("a bare key deletes the record with no variant and not the quants", () => {
+ store.clear();
+ savePerModelConfig(REPO_ID, null, config(2048));
+ savePerModelConfig(REPO_ID, QUANT, config(32768));
+
+ assert.equal(deletePerModelConfigsForOverrideKeys([REPO_ID]), true);
+
+ assert.equal(resolveInitialConfig(REPO_ID, null).remembered, false);
+ assert.equal(resolveInitialConfig(REPO_ID, QUANT).remembered, true);
+});
+
+test("a key this browser has no record for is nothing to delete", () => {
+ store.clear();
+ savePerModelConfig(REPO_ID, QUANT, config(32768));
+
+ assert.equal(
+ deletePerModelConfigsForOverrideKeys(["unsloth/Other-GGUF:Q8_0"]),
+ true,
+ );
+
+ assert.equal(resolveInitialConfig(REPO_ID, QUANT).remembered, true);
+});
+
+test("a record a newer build wrote is left behind and reported", () => {
+ store.clear();
+ const key = modelStorageKey(REPO_ID, QUANT);
+ store.set(
+ PER_MODEL_CONFIG_STORAGE_KEY,
+ JSON.stringify({ [key]: { version: 99, maxSeqLength: 32768 } }),
+ );
+
+ assert.equal(
+ deletePerModelConfigsForOverrideKeys([`${REPO_ID}:${QUANT}`]),
+ false,
+ );
+
+ assert.ok(
+ JSON.parse(store.get(PER_MODEL_CONFIG_STORAGE_KEY) ?? "{}")[key],
+ "the newer record must survive an older build's forget",
+ );
+});
+
+// The settings page's forget, mirrored through syncModelOverride.
+
+/** syncModelOverride is fire-and-forget; its cleanup lands after the response is read. */
+function settled(): Promise<void> {
+ return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+async function quietly(run: () => Promise<void>): Promise<void> {
+ const warn = console.warn;
+ console.warn = () => undefined;
+ try {
+ await run();
+ } finally {
+ console.warn = warn;
+ }
+}
+
+test("a forget resolves to the keys the server cleared", async () => {
+ respond(200, {
+ overrides: {},
+ // biome-ignore lint/style/useNamingConvention: API schema
+ removed_keys: [`${REPO_ID}:${QUANT}`, REPO_ID],
+ });
+
+ assert.deepEqual(await putModelOverride(REPO_ID, QUANT, null), {
+ overrides: {},
+ removedKeys: [`${REPO_ID}:${QUANT}`, REPO_ID],
+ });
+});
+
+test("a server that predates the field resolves to none, with the map it returned", async () => {
+ respond(200, { overrides: { "unsloth/Other-GGUF:Q8_0": {} } });
+
+ assert.deepEqual(await putModelOverride(REPO_ID, QUANT, null), {
+ overrides: { "unsloth/Other-GGUF:Q8_0": {} },
+ removedKeys: [],
+ });
+});
+
+test("a mirrored forget drops the records the server reports", async () => {
+ store.clear();
+ savePerModelConfig(REPO_ID, QUANT, SAVED);
+ savePerModelConfig(SNAPSHOT_PATH, QUANT, SAVED);
+ savePerModelConfig(REPO_ID, null, SAVED);
+ respond(200, {
+ overrides: {},
+ // biome-ignore lint/style/useNamingConvention: API schema
+ removed_keys: [`${REPO_ID}:${QUANT}`, REPO_ID, `${SNAPSHOT_PATH}:${QUANT}`],
+ });
+
+ syncModelOverride(REPO_ID, QUANT, null);
+ await settled();
+
+ assert.equal(listPerModelConfigs().length, 0);
+});
+
+// The settings page deletes its own record before the mirror answers; cleanup carries on past it.
+test("a mirrored forget from the settings page still drops the other spellings", async () => {
+ store.clear();
+ savePerModelConfig(SNAPSHOT_PATH, QUANT, SAVED);
+ savePerModelConfig(REPO_ID, null, SAVED);
+ respond(200, {
+ overrides: {},
+ // biome-ignore lint/style/useNamingConvention: API schema
+ removed_keys: [`${REPO_ID}:${QUANT}`, REPO_ID, `${SNAPSHOT_PATH}:${QUANT}`],
+ });
+
+ syncModelOverride(REPO_ID, QUANT, null);
+ await settled();
+
+ assert.equal(listPerModelConfigs().length, 0);
+});
+
+test("a mirrored save leaves this browser's records alone", async () => {
+ store.clear();
+ savePerModelConfig(REPO_ID, QUANT, SAVED);
+ respond(200, { overrides: {} });
+
+ syncModelOverride(REPO_ID, QUANT, SAVED);
+ await settled();
+
+ assert.equal(resolveInitialConfig(REPO_ID, QUANT).remembered, true);
+});
+
+test("a forget the server refused keeps this browser's records", async () => {
+ store.clear();
+ savePerModelConfig(REPO_ID, QUANT, SAVED);
+ respond(403, { detail: "Settings are read-only" });
+
+ await quietly(async () => {
+ syncModelOverride(REPO_ID, QUANT, null);
+ await settled();
+ });
+
+ assert.equal(resolveInitialConfig(REPO_ID, QUANT).remembered, true);
+});