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.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
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.pyindex 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] = Noneresolved_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.pyindex 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_sassert 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.tsxindex 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 thesesettings, the same ones you saved in the model's settings page.- Models without an entry load with app defaults. Edit or forget an- entry from that model'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'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.tsnew file mode 100644index 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.tsindex 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.tsxindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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);+});