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
Unsloth Studio: show which models have saved run settings and reset them from the model menu (#12608)
Leo Borcherding22812d8ebcd7
diff --git a/studio/frontend/src/features/model-picker/api/model-overrides.ts b/studio/frontend/src/features/model-picker/api/model-overrides.tsindex d7b2092773d..6488a88a920 100644--- a/studio/frontend/src/features/model-picker/api/model-overrides.ts+++ b/studio/frontend/src/features/model-picker/api/model-overrides.ts@@ -17,6 +17,7 @@ import {normalizeMlxKvQuant,type PerModelConfig,normalizePerModelConfig,+ perModelConfigSnapshot,} from "../model-config/per-model-config";import { forgetPerModelConfigsForOverrideKeys } from "../model-config/saved-run-settings";@@ -504,6 +505,9 @@ export function toApiOverride(config: PerModelConfig | null): ApiModelOverride {// One in-flight write per model so an older response cannot resurrect a replaced entry.const writesByKey = new Map<string, Promise<ModelOverrideWriteResult>>();+// A forget clears every alias of a cached repo on the server, so per-key order is not enough: it+// waits for every write in flight, and every write after it waits for the forget.+let forgetBarrier: Promise<unknown> = Promise.resolve();export interface ModelOverrideWriteResult {overrides: ApiModelOverrides;@@ -530,12 +534,18 @@ export async function putModelOverride(normalizeModelIdentity(modelId),normalizeGgufVariantIdentity(ggufVariant),);- // Chain on the settled tail: a failed write must not cancel the next one.- const previous = writesByKey.get(key) ?? Promise.resolve();- const write = previous- .catch(() => {})- .then(() => sendModelOverride(modelId, ggufVariant, config, options));+ const isForget = config === null && !options?.keepLaunchFlags;+ // Chain on the settled tails: a failed write must not cancel the next one.+ const previous = isForget+ ? Promise.allSettled([forgetBarrier, ...writesByKey.values()])+ : Promise.allSettled([forgetBarrier, writesByKey.get(key)]);+ const write = previous.then(() =>+ sendModelOverride(modelId, ggufVariant, config, options),+ );writesByKey.set(key, write);+ if (isForget) {+ forgetBarrier = write.catch(() => {});+ }try {return await write;} finally {@@ -616,6 +626,10 @@ async function sendModelOverride(};}+// Last write per folded key: a forget's cleanup spares any alias saved after it was sent.+let syncSeq = 0;+const lastWriteSeq = new Map<string, number>();+/** Best-effort: the localStorage write already happened, so failures are only logged. */export function syncModelOverride(modelId: string,@@ -623,9 +637,17 @@ export function syncModelOverride(config: PerModelConfig | null,options?: PutModelOverrideOptions,): void {+ const seq = ++syncSeq;+ lastWriteSeq.set(foldOverrideKey(modelOverrideKey(modelId, ggufVariant)), seq);+ // localStorage is shared, so this also catches a save from another tab meanwhile.+ const sent = config === null ? perModelConfigSnapshot() : undefined;void putModelOverride(modelId, ggufVariant, config, options).then(({ removedKeys }) => {- if (!forgetPerModelConfigsForOverrideKeys(removedKeys)) {+ // An undo, or a save under another alias, already rewrote what this forget reports.+ const stale = removedKeys.filter(+ (key) => (lastWriteSeq.get(foldOverrideKey(key)) ?? 0) <= seq,+ );+ if (!forgetPerModelConfigsForOverrideKeys(stale, sent)) {console.warn("Forgot model settings on the server, but this browser kept its own copy.",);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 c0081fe697d..0dc0aebbd15 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@@ -4161,6 +4161,12 @@ export function ModelConfigPage({<div className="mt-1.5 truncate text-ui-14 font-semibold leading-tight text-foreground">{target.displayName}</div>+ <div+ className="mt-1 truncate text-ui-11 leading-tight text-muted-foreground"+ aria-live="polite"+ >+ {saveStatus || "\u00a0"}+ </div></div></div>)}@@ -4492,7 +4498,7 @@ export function ModelConfigPage({}onClick={() => pickSet(pinnedSet)}>- Reset+ Reset all</Button>{target.isGguf && (<SharedRunConfigControlsdiff --git a/studio/frontend/src/features/model-picker/components/model-selector/model-load-settings-action.tsx b/studio/frontend/src/features/model-picker/components/model-selector/model-load-settings-action.tsxindex 1f112521fc0..014207dbfb9 100644--- a/studio/frontend/src/features/model-picker/components/model-selector/model-load-settings-action.tsx+++ b/studio/frontend/src/features/model-picker/components/model-selector/model-load-settings-action.tsx@@ -9,19 +9,24 @@ import {import { cn } from "@/lib/utils";import { Settings01Icon } from "@/lib/hugeicons-derived";import { HugeiconsIcon } from "@hugeicons/react";+import { useHasRememberedRunSettings } from "../../model-config/remembered-run-settings";+import type { ModelPickTarget } from "./types";export function ModelLoadSettingsAction({ariaLabel,onConfigure,className,tooltip = "Configure run settings before loading model",+ savedFor,}: {ariaLabel: string;onConfigure: () => void;className?: string;/** Hover copy. The default describes a local load, so Connected rows override it. */tooltip?: string;+ savedFor?: ModelPickTarget;}) {+ const saved = useHasRememberedRunSettings(savedFor ?? null);return (<Tooltip delayDuration={0}><TooltipTrigger asChild={true}>@@ -32,6 +37,7 @@ export function ModelLoadSettingsAction({onConfigure();}}aria-label={ariaLabel}+ data-run-settings-saved={saved || undefined}className={cn(// Fixed box so this and the dots menu hover at one size."flex size-5 shrink-0 items-center justify-center rounded-md text-muted-foreground/80 transition-colors hover:bg-[rgb(0_0_0_/_calc(0.05*var(--contrast-wash-gain,1)))] hover:text-foreground dark:hover:bg-[rgb(255_255_255_/_calc(0.1*var(--contrast-wash-gain,1)))]",@@ -46,7 +52,7 @@ export function ModelLoadSettingsAction({</button></TooltipTrigger><TooltipContent side="top" className="tooltip-compact">- {tooltip}+ {saved ? "Edit saved run settings" : tooltip}</TooltipContent></Tooltip>);diff --git a/studio/frontend/src/features/model-picker/components/model-selector/model-row-menu.tsx b/studio/frontend/src/features/model-picker/components/model-selector/model-row-menu.tsxindex eef31389cc0..76dd0092045 100644--- a/studio/frontend/src/features/model-picker/components/model-selector/model-row-menu.tsx+++ b/studio/frontend/src/features/model-picker/components/model-selector/model-row-menu.tsx@@ -28,6 +28,7 @@ import {MoreVerticalIcon,PinIcon,PinOffIcon,+ Undo02Icon,} from "@hugeicons/core-free-icons";import { Folder01Icon } from "@/lib/folder-icons";import { HugeiconsIcon } from "@hugeicons/react";@@ -38,6 +39,11 @@ import {useRef,useState,} from "react";+import {+ forgetRunSettings,+ useHasRememberedRunSettings,+} from "../../model-config/remembered-run-settings";+import type { ModelPickTarget } from "./types";/** Rendered under the pin and above cache/update, so delete stays last. */export interface ModelRowMenuItem {@@ -89,6 +95,7 @@ export function ModelRowMenu({onReveal,pin,items,+ runSettings,update,del,}: {@@ -99,6 +106,7 @@ export function ModelRowMenu({onReveal?: () => Promise<void>;pin?: ModelRowMenuPin;items?: readonly ModelRowMenuItem[];+ runSettings?: ModelPickTarget;update?: ModelRowMenuUpdate;del?: ModelRowMenuDelete;}) {@@ -180,8 +188,37 @@ export function ModelRowMenu({});}, [onReveal, cachePathRepoId, cachePathVariant]);+ const hasSavedRunSettings = useHasRememberedRunSettings(runSettings ?? null);+ const handleResetRunSettings = useCallback(() => {+ if (!runSettings) return;+ const undo = forgetRunSettings(runSettings);+ if (!undo) {+ toast.error("Could not reset run settings");+ return;+ }+ toast.success(`Run settings reset for ${runSettings.displayName}`, {+ description: "Takes effect the next time it loads.",+ // Longer than a status toast: this one carries the only way back.+ duration: 10000,+ action: {+ label: "Undo",+ onClick: () => {+ if (!undo()) toast.error("Could not restore run settings");+ },+ },+ });+ }, [runSettings]);+const canReveal = Boolean(revealLabel && (cachePath || onReveal));- if (!pin && !update && !del && !canReveal && !items?.length) return null;+ if (+ !pin &&+ !update &&+ !del &&+ !canReveal &&+ !items?.length &&+ !hasSavedRunSettings+ )+ return null;return (<>@@ -237,6 +274,21 @@ export function ModelRowMenu({<span>{item.label}</span></DropdownMenuItem>))}+ {hasSavedRunSettings && (+ <DropdownMenuItem+ onSelect={(e) => {+ e.stopPropagation();+ handleResetRunSettings();+ }}+ >+ <HugeiconsIcon+ icon={Undo02Icon}+ strokeWidth={1.75}+ className="size-icon"+ />+ <span>Reset run settings</span>+ </DropdownMenuItem>+ )}{canReveal && (<DropdownMenuItemonSelect={(e) => {@@ -266,7 +318,11 @@ export function ModelRowMenu({)}{del && (<>- {(canReveal || pin || update || items?.length) && (+ {(canReveal ||+ pin ||+ update ||+ items?.length ||+ hasSavedRunSettings) && (<DropdownMenuSeparator />)}<DropdownMenuItemdiff --git a/studio/frontend/src/features/model-picker/components/model-selector/pickers.tsx b/studio/frontend/src/features/model-picker/components/model-selector/pickers.tsxindex c694d355911..31de3d63a63 100644--- a/studio/frontend/src/features/model-picker/components/model-selector/pickers.tsx+++ b/studio/frontend/src/features/model-picker/components/model-selector/pickers.tsx@@ -177,6 +177,8 @@ import {} from "../../../audio/audio-cpp-catalog.ts";import { audioPickSearch } from "../../../audio/route-search.ts";import { useChatPickerInventory } from "../../inventory/use-chat-picker-inventory";+import { modelConfigTarget } from "../../model-config/model-config-handoff";+import { useHasRememberedRunSettings } from "../../model-config/remembered-run-settings";import {type CommunityModelPolicy,allowedHiddenModelIdMatches,@@ -303,6 +305,7 @@ import type {LoraModelOption,ModelDownloadFootprintResolver,ModelOption,+ ModelPickTarget,ModelSelectorChangeMeta,} from "./types";import { type PinnedDropEdge, usePinnedRowDrag } from "./use-pinned-row-drag";@@ -1199,7 +1202,7 @@ const downloadedRowShellClassName = (// One gutter for every row so columns never shift by a button.const ROW_ACTIONS_CLASS =- "mr-0.5 flex w-[calc(38px*var(--ui-space-scale,1))] shrink-0 items-center justify-end -space-x-0.5 opacity-0 transition-opacity focus-within:opacity-100 group-hover:opacity-100 group-focus-within:opacity-100 has-[[data-state=open]]:opacity-100 [@media(hover:none)]:opacity-100";+ "mr-0.5 flex w-[calc(38px*var(--ui-space-scale,1))] shrink-0 items-center justify-end -space-x-0.5 opacity-0 transition-opacity focus-within:opacity-100 group-hover:opacity-100 group-focus-within:opacity-100 has-[[data-state=open]]:opacity-100 has-[[data-run-settings-saved]]:opacity-100 [@media(hover:none)]:opacity-100";const ROW_ACTIONS_VISIBLE_CLASS = ROW_ACTIONS_CLASS.replace("opacity-0 ", "");@@ -1816,6 +1819,31 @@ function useDeviceExpanderCallbacks(};}+/** A quant with no other menu still offers Reset once its settings are saved before download. */+function SavedRunSettingsMenu({+ ariaLabel,+ runSettings,+ reserveSlot,+}: {+ ariaLabel: string;+ runSettings: ModelPickTarget | undefined;+ reserveSlot: boolean;+}) {+ const saved = useHasRememberedRunSettings(runSettings ?? null);+ if (saved) {+ return (+ <ModelRowMenu+ ariaLabel={ariaLabel}+ iconClassName="size-3"+ runSettings={runSettings}+ />+ );+ }+ return reserveSlot ? (+ <span className="size-5 shrink-0" aria-hidden={true} />+ ) : null;+}+const DownloadedModelDeviceRow = memo(function DownloadedModelDeviceRow({model: c,optionKey,@@ -1839,6 +1867,20 @@ const DownloadedModelDeviceRow = memo(function DownloadedModelDeviceRow({}) {// A partial pick must not claim downloaded, or the load fails on missing shards.const isPartial = c.partial === true;+ const gearMeta: ModelSelectorChangeMeta = {+ source: "hub",+ isLora: false,+ // No load identity for an incomplete snapshot.+ loadId: isPartial ? undefined : c.load_id,+ isDownloaded: !isPartial,+ isGguf: false,+ pipelineTag: c.task ?? null,+ audioType: c.audio_type ?? null,+ familyOverrideRequired: c.opaque === true,+ };+ const configTarget = canConfigure+ ? modelConfigTarget(c.repo_id, gearMeta)+ : undefined;return (<div className={downloadedRowShellClassName(isSelected)}><div className="min-w-0 flex-1">@@ -1880,25 +1922,15 @@ const DownloadedModelDeviceRow = memo(function DownloadedModelDeviceRow({{canConfigure && (<ModelLoadSettingsActionariaLabel={`Inference settings for ${c.repo_id}`}- onConfigure={() =>- actions.get().configure(c.repo_id, {- source: "hub",- isLora: false,- // No load identity for an incomplete snapshot.- loadId: isPartial ? undefined : c.load_id,- isDownloaded: !isPartial,- isGguf: false,- pipelineTag: c.task ?? null,- audioType: c.audio_type ?? null,- familyOverrideRequired: c.opaque === true,- })- }+ onConfigure={() => actions.get().configure(c.repo_id, gearMeta)}+ savedFor={configTarget}/>)}<ModelRowMenuariaLabel={`More options for ${c.repo_id}`}cachePath={{ repoId: c.repo_id }}items={ejectMenuItemsFor(actions, c.repo_id, ejectable)}+ runSettings={configTarget}pin={{pinned,pinLabel: "Pin",@@ -2054,6 +2086,9 @@ const SoleQuantGgufDeviceRow = memo(function SoleQuantGgufDeviceRow({isVision: sole.hasVision === false ? false : undefined,pipelineTag: c.task ?? null,};+ const configTarget = canConfigure+ ? modelConfigTarget(c.repo_id, selectMeta)+ : undefined;return (<div><div className={downloadedRowShellClassName(isSelected, true)}>@@ -2114,11 +2149,13 @@ const SoleQuantGgufDeviceRow = memo(function SoleQuantGgufDeviceRow({<ModelLoadSettingsActionariaLabel={`Inference settings for ${onDeviceRepoLabel(c.repo_id)} ${variant.quant}`}onConfigure={() => actions.get().configure(c.repo_id, selectMeta)}+ savedFor={configTarget}/>)}<ModelRowMenuariaLabel={`More options for ${onDeviceRepoLabel(c.repo_id)} ${variant.quant}`}cachePath={{ repoId: c.repo_id, variant: variant.quant }}+ runSettings={configTarget}// The expander reads Hub-only state (updates, companions); a collapsed row never asks.items={[...(ejectMenuItemsFor(actions, c.repo_id, ejectable) ?? []),@@ -2425,6 +2462,7 @@ const LocalModelDeviceRow = memo(function LocalModelDeviceRow({onConfigure={() =>actions.get().configure(m.id, localDirectGgufMeta(m.task))}+ savedFor={modelConfigTarget(m.id, localDirectGgufMeta(m.task))}/>)}{!isGguf && canConfigure && (@@ -2438,6 +2476,10 @@ const LocalModelDeviceRow = memo(function LocalModelDeviceRow({localModelMeta(false, m.task, m.audio_type, m.opaque === true),)}+ savedFor={modelConfigTarget(+ m.id,+ localModelMeta(false, m.task, m.audio_type, m.opaque === true),+ )}/>)}<ModelRowMenu@@ -3246,6 +3288,10 @@ function GgufVariantExpander({pendingDrafterPresentation(v),variantContext,);+ // Settings can be saved before the download, so every quant shows its own.+ const configTarget = onConfigure+ ? modelConfigTarget(repoId, selectMeta)+ : undefined;const rowButton = (<buttontype="button"@@ -3363,15 +3409,21 @@ function GgufVariantExpander({"opacity-0 transition-opacity focus-visible:opacity-100 group-hover/quant:opacity-100 group-focus-within/quant:opacity-100 [@media(hover:none)]:opacity-100",)}onConfigure={() => onConfigure(repoId, selectMeta)}+ savedFor={configTarget}/>)}- {!variantHasMenu(v) && reserveMenuSlot && (- <span className="size-5 shrink-0" aria-hidden={true} />+ {!variantHasMenu(v) && (+ <SavedRunSettingsMenu+ ariaLabel={`More options for ${repoId} ${v.quant}`}+ runSettings={configTarget}+ reserveSlot={reserveMenuSlot}+ />)}{variantHasMenu(v) && (<ModelRowMenuariaLabel={`More options for ${repoId} ${v.quant}`}iconClassName="size-3"+ runSettings={configTarget}cachePath={isLocalPath ? undefined : { repoId, variant: v.quant }}@@ -6996,21 +7048,22 @@ export function HubModelPicker({</div>);}+ const configId = cachedIdFor(id) ?? id;+ const configMeta: ModelSelectorChangeMeta = {+ source: "hub",+ isLora: false,+ isGguf: false,+ isDownloaded: cachedIdFor(id) !== null,+ pipelineTag: pipelineTagById.get(id) ?? null,+ };return (<div className={downloadedRowShellClassName(isValueRow(id))}><div className="min-w-0 flex-1">{row}</div><span className={ROW_ACTIONS_CLASS}><ModelLoadSettingsActionariaLabel={`Inference settings for ${id}`}- onConfigure={() =>- onConfigure(cachedIdFor(id) ?? id, {- source: "hub",- isLora: false,- isGguf: false,- isDownloaded: cachedIdFor(id) !== null,- pipelineTag: pipelineTagById.get(id) ?? null,- })- }+ onConfigure={() => onConfigure(configId, configMeta)}+ savedFor={modelConfigTarget(configId, configMeta)}/></span></div>@@ -7122,6 +7175,9 @@ export function HubModelPicker({? { ...selectMeta, ggufVariant: undefined, isGguf: true }: selectMeta,];+ const configTarget = onConfigure+ ? modelConfigTarget(...configureArgs)+ : undefined;// A path load keeps the menu. A cached download pins and reveals as its repo: the local// reveal endpoint only lists non-cache sources, so it would 404.const pinRepoId = !isLocal@@ -7165,10 +7221,12 @@ export function HubModelPicker({<ModelLoadSettingsActionariaLabel={`Inference settings for ${entry.id}`}onConfigure={() => onConfigure(...configureArgs)}+ savedFor={configTarget}/>)}<ModelRowMenuariaLabel={`More options for ${entry.id}`}+ runSettings={configTarget}cachePath={pinRepoId === null ? undefined : { repoId: pinRepoId, variant: quant ?? undefined }}@@ -7390,6 +7448,18 @@ export function HubModelPicker({const hasVision =pinnedQuantValidation.visionByRepo.get(entry.repoId) ??sortedCachedGguf.find((c) => c.repo_id === entry.repoId)?.has_vision;+ const configMeta: ModelSelectorChangeMeta = {+ source: "hub",+ isLora: false,+ ggufVariant: entry.quant,+ isDownloaded: true,+ isGguf: true,+ isVision: pinnedVisionHint,+ pipelineTag: diffusionTaskById.get(entry.repoId.toLowerCase()) ?? null,+ };+ const configTarget = onConfigure+ ? modelConfigTarget(entry.repoId, configMeta)+ : undefined;return (<divkey={optionKey}@@ -7447,23 +7517,14 @@ export function HubModelPicker({{onConfigure && (<ModelLoadSettingsActionariaLabel={`Inference settings for ${entry.repoId} ${entry.quant}`}- onConfigure={() =>- onConfigure(entry.repoId, {- source: "hub",- isLora: false,- ggufVariant: entry.quant,- isDownloaded: true,- isGguf: true,- isVision: pinnedVisionHint,- pipelineTag:- diffusionTaskById.get(entry.repoId.toLowerCase()) ?? null,- })- }+ onConfigure={() => onConfigure(entry.repoId, configMeta)}+ savedFor={configTarget}/>)}<ModelRowMenuariaLabel={`More options for ${entry.repoId} ${entry.quant}`}cachePath={{ repoId: entry.repoId, variant: entry.quant }}+ runSettings={configTarget}pin={{pinned: true,pinLabel: "Pin",@@ -7771,16 +7832,13 @@ export function HubModelPicker({className={onDevice ? downloadedRowButtonClassName : undefined}/>);+ const configMeta = { ...meta, contextLength: model.max_context_length };const settings =onConfigure && model.downloaded && !downloading ? (<ModelLoadSettingsActionariaLabel={`Inference settings for ${model.id}`}- onConfigure={() =>- onConfigure(model.model_path, {- ...meta,- contextLength: model.max_context_length,- })- }+ onConfigure={() => onConfigure(model.model_path, configMeta)}+ savedFor={modelConfigTarget(model.model_path, configMeta)}/>) : null;if (!onDevice && !onConfigure) return <div key={model.id}>{row}</div>;@@ -9185,6 +9243,10 @@ function FineTunedRows({audioType: adapter.audioType ?? null,};const canConfigure = !(isLocalGgufDir || isExportedGguf);+ const configTarget =+ canConfigure && onConfigure+ ? modelConfigTarget(adapter.id, selectionMeta)+ : undefined;const optionKey = makeModelOptionKey("lora", adapter.id);const tag = isLocal? isLocalGgufDir || isLocalDirectGguf@@ -9272,10 +9334,12 @@ function FineTunedRows({<ModelLoadSettingsActionariaLabel={`Inference settings for ${adapter.name}`}onConfigure={() => onConfigure(adapter.id, selectionMeta)}+ savedFor={configTarget}/>)}<ModelRowMenuariaLabel={`More options for ${adapter.name}`}+ runSettings={configTarget}pin={{pinned: pinnedKeys.includes(pinKey(adapter.id)),pinLabel: "Pin",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 aad9d7abedc..7af4994f098 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@@ -1449,7 +1449,13 @@ export function savePerModelConfig(if (!enforceStorageBudget(map, new Set([key]), evictedKeys)) {return false;}+ // Stamp first: a forget's cleanup in another tab between the two writes then keeps+ // an identical re-save instead of reading it as the record it snapshotted.+ const previousStamps = stampWrite(key, map);const written = writeMap(map);+ if (!written) {+ restoreStamps(previousStamps);+ }if (written && evicted) {for (const evictedKey of evictedKeys) {const id = modelIdFromStorageKey(evictedKey);@@ -1494,8 +1500,21 @@ export function listPerModelConfigs(): {export function deletePerModelConfig(modelId: string,ggufVariant?: string | null,+ /** Keep the record under `storageKey` if it was saved after `since`. */+ unchanged?: { storageKey: string; since: PerModelConfigSnapshot },): boolean {const map = readMap();+ // Checked against the map this delete writes back, records then stamps, so the only+ // window left is the store's own synchronous read-modify-write.+ if (+ unchanged &&+ perModelConfigChangedSince(unchanged.storageKey, unchanged.since, {+ records: map,+ stamps: readStamps(),+ })+ ) {+ return true;+ }if (hasFutureConfigForModelVariant(map, modelId, ggufVariant)) {return false;}@@ -1508,10 +1527,14 @@ export function deletePerModelConfig(/** 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 }[] {+): { modelId: string; ggufVariant: string | null; storageKey: string }[] {const key = overrideKey.trim();const foldedKey = normalizeModelIdentity(key);- const owners: { modelId: string; ggufVariant: string | null }[] = [];+ const owners: {+ modelId: string;+ ggufVariant: string | null;+ storageKey: string;+ }[] = [];for (const storageKey of Object.keys(readMap())) {const modelId = modelIdFromStorageKey(storageKey);if (!modelId) {@@ -1523,7 +1546,7 @@ function findModelOverrideKeyOwners();if (!variant) {if (foldedKey === normalizeModelIdentity(modelId)) {- owners.push({ modelId, ggufVariant: null });+ owners.push({ modelId, ggufVariant: null, storageKey });}continue;}@@ -1535,27 +1558,110 @@ function findModelOverrideKeyOwners(normalizeModelIdentity(key.slice(0, cut)) ===normalizeModelIdentity(modelId)) {- owners.push({ modelId, ggufVariant: variant });+ owners.push({ modelId, ggufVariant: variant, storageKey });}}return owners;}+// A unique mark per save, beside the records, so another tab's identical re-save still reads as new.+const WRITE_STAMPS_KEY = "unsloth_model_config_stamps";++function readStamps(): Record<string, string> {+ if (!canUseStorage()) {+ return {};+ }+ try {+ const parsed = JSON.parse(localStorage.getItem(WRITE_STAMPS_KEY) ?? "{}");+ return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};+ } catch {+ return {};+ }+}++function stampWrite(key: string, map: StoredMap): string | null {+ let previous: string | null = null;+ try {+ previous = canUseStorage() ? localStorage.getItem(WRITE_STAMPS_KEY) : null;+ } catch {+ // Unreadable storage: the record write fails next and there is nothing to restore.+ }+ const stamps: Record<string, string> = {};+ for (const [k, v] of Object.entries(readStamps())) {+ if (k in map) {+ stamps[k] = v;+ }+ }+ stamps[key] = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;+ try {+ localStorage.setItem(WRITE_STAMPS_KEY, JSON.stringify(stamps));+ } catch {+ // Best-effort: without it a forget's cleanup falls back to comparing contents.+ }+ return previous;+}++function restoreStamps(previous: string | null): void {+ try {+ if (previous === null) {+ localStorage.removeItem(WRITE_STAMPS_KEY);+ } else {+ localStorage.setItem(WRITE_STAMPS_KEY, previous);+ }+ } catch {+ // Best-effort, as in stampWrite.+ }+}++export type PerModelConfigSnapshot = {+ readonly records: Readonly<Record<string, unknown>>;+ readonly stamps: Readonly<Record<string, string>>;+};++// A save writes its stamp before its record. The baseline reads stamps first and the+// re-read records first, so a save landing between two reads always shows as a change.+export function perModelConfigSnapshot(): PerModelConfigSnapshot {+ const stamps = readStamps();+ return { records: readMapRaw(), stamps };+}++function currentPerModelConfigSnapshot(): PerModelConfigSnapshot {+ const records = readMapRaw();+ return { records, stamps: readStamps() };+}+export function modelOverrideKeyOwners(overrideKeys: readonly string[],-): { modelId: string; ggufVariant: string | null }[] {+): { modelId: string; ggufVariant: string | null; storageKey: string }[] {return overrideKeys.flatMap(findModelOverrideKeyOwners);}+/** True when the record under ``storageKey`` was written after ``since`` (in any tab). */+export function perModelConfigChangedSince(+ storageKey: string,+ since: PerModelConfigSnapshot,+ current: PerModelConfigSnapshot = currentPerModelConfigSnapshot(),+): boolean {+ return (+ current.stamps[storageKey] !== since.stamps[storageKey] ||+ JSON.stringify(current.records[storageKey]) !==+ JSON.stringify(since.records[storageKey])+ );+}++/** Delete the records the server keys name; false when one was left behind. With+ * `unchangedSince`, a record written after that snapshot is kept. */export function deletePerModelConfigsForOverrideKeys(overrideKeys: readonly string[],+ unchangedSince?: PerModelConfigSnapshot,): boolean {let deleted = true;- for (const overrideKey of overrideKeys) {- for (const owner of findModelOverrideKeyOwners(overrideKey)) {- if (!deletePerModelConfig(owner.modelId, owner.ggufVariant)) {- deleted = false;- }+ for (const owner of modelOverrideKeyOwners(overrideKeys)) {+ const unchanged = unchangedSince+ ? { storageKey: owner.storageKey, since: unchangedSince }+ : undefined;+ if (!deletePerModelConfig(owner.modelId, owner.ggufVariant, unchanged)) {+ deleted = false;}}return deleted;diff --git a/studio/frontend/src/features/model-picker/model-config/remembered-run-settings.ts b/studio/frontend/src/features/model-picker/model-config/remembered-run-settings.tsnew file mode 100644index 00000000000..fc041483139--- /dev/null+++ b/studio/frontend/src/features/model-picker/model-config/remembered-run-settings.ts@@ -0,0 +1,210 @@+// 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 { useSyncExternalStore } from "react";+import { syncModelOverride } from "../api/model-overrides";+import type { ModelPickTarget } from "../components/model-selector/types";+import {+ type ModelConfigDraftSnapshot,+ isModelConfigDraftEdited,+ modelConfigDraftKey,+ readModelConfigDraft,+ replaceModelConfigDraft,+ setModelConfigDraftRemember,+} from "./model-config-draft";+import { modelStorageKey } from "./model-identity";+import {+ getPinnedRunSettings,+ getSelectedRunSettings,+ setPinnedRunSettings,+ setSelectedRunSettings,+} from "./saved-run-settings";+import {+ PER_MODEL_CONFIG_STORAGE_KEY,+ PER_MODEL_CONFIG_UPDATED_EVENT,+ type PerModelConfig,+ deletePerModelConfig,+ resolveInitialConfig,+ savePerModelConfig,+} from "./per-model-config";++// Every picker row asks, so answers are cached until the next write rather than re-parsing the map per row.+let savedByKey = new Map<string, PerModelConfig | null>();+const listeners = new Set<() => void>();+let detach: (() => void) | null = null;+// What the cache was read from while unsubscribed, when only a re-read can notice a write.+let cachedRaw: string | null | undefined;++function invalidate(): void {+ savedByKey = new Map();+ cachedRaw = undefined;+}++function storedRaw(): string | null {+ try {+ return localStorage.getItem(PER_MODEL_CONFIG_STORAGE_KEY);+ } catch {+ return null;+ }+}++function settingsKey(target: ModelPickTarget): [string, string | null] {+ return [target.configId ?? target.id, target.ggufVariant ?? null];+}++/** The settings this row would load with, or null when nothing is saved for it. */+export function rememberedRunSettings(+ target: ModelPickTarget,+): PerModelConfig | null {+ const [id, variant] = settingsKey(target);+ const key = modelStorageKey(id, variant);+ // Cached either way, since useSyncExternalStore needs a stable snapshot before it subscribes.+ if (!detach) {+ const raw = storedRaw();+ if (raw !== cachedRaw) {+ invalidate();+ cachedRaw = raw;+ }+ }+ const cached = savedByKey.get(key);+ if (cached !== undefined) {+ return cached;+ }+ const resolved = resolveInitialConfig(id, variant);+ const value = resolved.remembered ? resolved.config : null;+ savedByKey.set(key, value);+ if (!detach) {+ // The first read can migrate legacy records into the store; that is not a new write.+ cachedRaw = storedRaw();+ }+ return value;+}++function notify(): void {+ invalidate();+ for (const listener of [...listeners]) {+ listener();+ }+}++export function subscribeRememberedRunSettings(onChange: () => void): () => void {+ listeners.add(onChange);+ if (!detach && typeof window?.addEventListener === "function") {+ // Writes made while nobody listened never invalidated the cache; an unchanged store keeps+ // the snapshot React already rendered, so subscribing doesn't force a second render.+ if (storedRaw() !== cachedRaw) {+ invalidate();+ }+ const onStorage = (event: StorageEvent) => {+ if (event.key === null || event.key === PER_MODEL_CONFIG_STORAGE_KEY) {+ notify();+ }+ };+ window.addEventListener(PER_MODEL_CONFIG_UPDATED_EVENT, notify);+ window.addEventListener("storage", onStorage);+ detach = () => {+ window.removeEventListener(PER_MODEL_CONFIG_UPDATED_EVENT, notify);+ window.removeEventListener("storage", onStorage);+ };+ }+ return () => {+ listeners.delete(onChange);+ if (listeners.size === 0 && detach) {+ detach();+ detach = null;+ invalidate();+ }+ };+}++export function useHasRememberedRunSettings(+ target: ModelPickTarget | null,+): boolean {+ return useSyncExternalStore(+ subscribeRememberedRunSettings,+ () => (target ? rememberedRunSettings(target) !== null : false),+ () => false,+ );+}++// An editor opened after the reset seeded defaults; left alone, its next load forgets again.+function restoreDraftAfterUndo(+ draftKey: string,+ atReset: ModelConfigDraftSnapshot | null,+ snapshot: PerModelConfig,+): void {+ const draft = readModelConfigDraft(draftKey);+ if (!draft || (atReset && !atReset.savedRemember)) {+ return;+ }+ if (+ !atReset &&+ draft.appliedLiveSignature === "none" &&+ !isModelConfigDraftEdited(draftKey)+ ) {+ replaceModelConfigDraft(draftKey, snapshot, {+ remember: true,+ savedRemember: true,+ });+ return;+ }+ setModelConfigDraftRemember(draftKey, true, true);+}++/** Drops a model's saved run settings here and on the server, like the panel's Forget. Returns an+ * undo that puts them back, or null when there was nothing to forget or the delete failed. */+export function forgetRunSettings(+ target: ModelPickTarget,+): (() => boolean) | null {+ const [id, variant] = settingsKey(target);+ const resolved = resolveInitialConfig(id, variant);+ if (!resolved.remembered) {+ return null;+ }+ const snapshot = resolved.config;+ if (!deletePerModelConfig(id, variant)) {+ return null;+ }+ // Back on Default, as a server-side forget does: a set left selected would no longer load.+ const selected = getSelectedRunSettings(id, variant);+ const pinned = getPinnedRunSettings(id, variant);+ if (typeof selected === "string") {+ setSelectedRunSettings(id, variant, null);+ }+ if (pinned !== null) {+ setPinnedRunSettings(id, variant, null);+ }+ const mirrored = target.apiLoadable ?? target.isGguf;+ if (mirrored) {+ syncModelOverride(id, variant, null);+ }+ // The loaded model's editor stays mounted in the sidebar, so its draft would keep saying saved.+ const draftKey = modelConfigDraftKey(id, variant);+ const draft = readModelConfigDraft(draftKey);+ if (draft?.savedRemember) {+ setModelConfigDraftRemember(draftKey, false, false);+ }+ return () => {+ // A save since the reset (this tab or another) is newer than the snapshot.+ if (+ resolveInitialConfig(id, variant).remembered ||+ !savePerModelConfig(id, variant, snapshot)+ ) {+ return false;+ }+ if (mirrored) {+ syncModelOverride(id, variant, snapshot);+ }+ if (+ typeof selected === "string" &&+ getSelectedRunSettings(id, variant) === null+ ) {+ setSelectedRunSettings(id, variant, selected);+ }+ if (pinned !== null && getPinnedRunSettings(id, variant) === null) {+ setPinnedRunSettings(id, variant, pinned);+ }+ restoreDraftAfterUndo(draftKey, draft ?? null, snapshot);+ return true;+ };+}diff --git a/studio/frontend/src/features/model-picker/model-config/saved-run-settings.ts b/studio/frontend/src/features/model-picker/model-config/saved-run-settings.tsindex 68bb51c7c86..b53b96dc722 100644--- a/studio/frontend/src/features/model-picker/model-config/saved-run-settings.ts+++ b/studio/frontend/src/features/model-picker/model-config/saved-run-settings.ts@@ -8,10 +8,12 @@ import { useSyncExternalStore } from "react";import { normalizeModelIdentity } from "./model-identity";import {type PerModelConfig,+ type PerModelConfigSnapshot,deletePerModelConfigsForOverrideKeys,fromStoredPerModelConfig,isChatTemplateWithinLimit,modelOverrideKeyOwners,+ perModelConfigChangedSince,toStoredPerModelConfig,} from "./per-model-config";@@ -368,12 +370,22 @@ export function setSelectedRunSettings(/** Back on Default too: a selection left behind would show a set that no longer loads. */export function forgetPerModelConfigsForOverrideKeys(overrideKeys: readonly string[],+ unchangedSince?: PerModelConfigSnapshot,): boolean {const selections = readSelections();const pins = readPins();let changed = false;let unpinned = false;- for (const { modelId, ggufVariant } of modelOverrideKeyOwners(overrideKeys)) {+ for (const { modelId, ggufVariant, storageKey } of modelOverrideKeyOwners(+ overrideKeys,+ )) {+ // Saved again since the forget was sent: that record keeps its set too.+ if (+ unchangedSince &&+ perModelConfigChangedSince(storageKey, unchangedSince)+ ) {+ continue;+ }const key = selectionKey(modelId, ggufVariant);if (typeof selections[key] === "string") {selections[key] = null;@@ -390,7 +402,7 @@ export function forgetPerModelConfigsForOverrideKeys(if (changed) {writeSelections(selections);}- return deletePerModelConfigsForOverrideKeys(overrideKeys);+ return deletePerModelConfigsForOverrideKeys(overrideKeys, unchangedSince);}// The set a one-time load used and what it sent: the runtime reports resolved values, so sets alonediff --git a/studio/frontend/src/features/settings/tabs/general-tab.tsx b/studio/frontend/src/features/settings/tabs/general-tab.tsxindex 130b6443053..299bf758a76 100644--- a/studio/frontend/src/features/settings/tabs/general-tab.tsx+++ b/studio/frontend/src/features/settings/tabs/general-tab.tsx@@ -176,6 +176,7 @@ const PREFS_KEYS: string[] = ["unsloth_chat_preferences","unsloth_model_configs","unsloth_model_configs_migrated",+ "unsloth_model_config_stamps","unsloth_load_settings","unsloth_model_advanced_settings","unsloth_chat_load_on_selection",diff --git a/studio/frontend/tests/model-picker-gguf-quant-settings.test.ts b/studio/frontend/tests/model-picker-gguf-quant-settings.test.tsindex 48ad5d5b7bb..898f06bffa9 100644--- a/studio/frontend/tests/model-picker-gguf-quant-settings.test.ts+++ b/studio/frontend/tests/model-picker-gguf-quant-settings.test.ts@@ -72,8 +72,13 @@ test("a quant without a menu keeps its slot so gears line up", () => {picker,/const reserveMenuSlot = \(displayVariants \?\? \[\]\)\.some\(variantHasMenu\);/,);+ // The slot is held inside SavedRunSettingsMenu, which shows Reset there once settings are saved.assert.match(picker,- /\{!variantHasMenu\(v\) && reserveMenuSlot && \(\s*<span className="size-5 shrink-0" aria-hidden=\{true\} \/>\s*\)\}\s*\{variantHasMenu\(v\) && \(\s*<ModelRowMenu/,+ /\{!variantHasMenu\(v\) && \(\s*<SavedRunSettingsMenu[^/]*reserveSlot=\{reserveMenuSlot\}\s*\/>\s*\)\}\s*\{variantHasMenu\(v\) && \(\s*<ModelRowMenu/,+ );+ assert.match(+ picker,+ /return reserveSlot \? \(\s*<span className="size-5 shrink-0" aria-hidden=\{true\} \/>\s*\) : null;/,);});diff --git a/studio/frontend/tests/override-forget-alias-order.test.ts b/studio/frontend/tests/override-forget-alias-order.test.tsnew file mode 100644index 00000000000..41ca3eab128--- /dev/null+++ b/studio/frontend/tests/override-forget-alias-order.test.ts@@ -0,0 +1,60 @@+// 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();+installLocalStorageFake();++const { putModelOverride } = await import(+ "../src/features/model-picker/api/model-overrides.ts"+);+const { DEFAULT_PER_MODEL_CONFIG } = await import(+ "../src/features/model-picker/model-config/per-model-config.ts"+);+const { setAuthFetchHandler } = await import("./helpers/store-stubs/auth.ts");++const REPO = "unsloth/Qwen3-4B-GGUF";+const SNAPSHOT = "C:/hf/models--unsloth--Qwen3-4B-GGUF/snapshots/abc";++test("a forget and a later save under another alias reach the server in order", async () => {+ const arrived: string[] = [];+ const releases: (() => void)[] = [];+ setAuthFetchHandler(async (_input, init) => {+ const body = JSON.parse(String(init?.body ?? "{}"));+ // Hold each request until released, so arrival order is what the client chose.+ await new Promise<void>((resolve) => releases.push(resolve));+ arrived.push(+ body.remove ? `forget ${body.model_id}` : `save ${body.model_id}`,+ );+ return new Response(JSON.stringify({ overrides: {}, removed_keys: [] }), {+ status: 200,+ headers: { "content-type": "application/json" },+ });+ });+ try {+ const save = { ...DEFAULT_PER_MODEL_CONFIG, nParallel: 2 };+ const forget = putModelOverride(REPO, "Q4_K_M", null);+ const later = putModelOverride(SNAPSHOT, "Q4_K_M", save);+ await new Promise((resolve) => setTimeout(resolve, 0));+ // Only the forget may be on the wire; the alias save waits behind it.+ assert.equal(releases.length, 1);+ releases.shift()?.();+ await forget;+ await new Promise((resolve) => setTimeout(resolve, 0));+ releases.shift()?.();+ await later;+ assert.deepEqual(arrived, [+ `forget ${REPO}:Q4_K_M`,+ `save ${SNAPSHOT}:Q4_K_M`,+ ]);+ } finally {+ setAuthFetchHandler(null);+ }+});diff --git a/studio/frontend/tests/recommended-curated-row-metadata.test.ts b/studio/frontend/tests/recommended-curated-row-metadata.test.tsindex be792dadbfe..60ceaab72a1 100644--- a/studio/frontend/tests/recommended-curated-row-metadata.test.ts+++ b/studio/frontend/tests/recommended-curated-row-metadata.test.ts@@ -351,20 +351,24 @@ test("Hub settings configure the cached alias and share the row selection", () =const render = new Function("React", "isKnownGgufRepo", "onConfigure", "downloadedRowShellClassName","isValueRow", "ROW_ACTIONS_CLASS", "ModelLoadSettingsAction", "cachedIdFor", "pipelineTagById",+ "modelConfigTarget",`${compiled}; return render;`,)(React, () => false, (...args: unknown[]) => calls.push(args),(selected: boolean) => selected ? "selected" : "idle", () => true,"actions", "settings", (id: string) => id === "mirror/model" ? "vendor/model" : null,new Map([["mirror/model", "text-generation"]]),+ (id: string, meta: unknown) => ({ id, meta }),);const row = render("mirror/model", "model row");assert.equal(row.props.className, "selected");- row.children[1].children[0].props.onConfigure();+ const gear = row.children[1].children[0].props;+ gear.onConfigure();assert.deepEqual(calls[0], ["vendor/model", {source: "hub", isLora: false, isGguf: false, isDownloaded: true,pipelineTag: "text-generation",}]);+ assert.deepEqual(gear.savedFor, { id: calls[0][0], meta: calls[0][1] });render("new/model", "model row").children[1].children[0].props.onConfigure();assert.deepEqual(calls[1], ["new/model", {source: "hub", isLora: false, isGguf: false, isDownloaded: false, pipelineTag: null,diff --git a/studio/frontend/tests/remembered-run-settings-legacy-snapshot.test.ts b/studio/frontend/tests/remembered-run-settings-legacy-snapshot.test.tsnew file mode 100644index 00000000000..6635aa01822--- /dev/null+++ b/studio/frontend/tests/remembered-run-settings-legacy-snapshot.test.ts@@ -0,0 +1,44 @@+// 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";++// Its own file: the legacy import is latched per process, so it must be the first read here.+registerStoreStubResolver();+const { store } = installLocalStorageFake();++const REPO = "unsloth/gemma-3-270m-it-GGUF";+const QUANT = "UD-Q4_K_XL";+store.set(+ "unsloth_load_settings",+ JSON.stringify({+ [`${REPO}::${QUANT}`]: { contextLength: 4096, kvCacheDtype: "q8_0" },+ }),+);++const { rememberedRunSettings } = await import(+ "../src/features/model-picker/model-config/remembered-run-settings.ts"+);+const { modelConfigTarget } = await import(+ "../src/features/model-picker/model-config/model-config-handoff.ts"+);++test("the read that migrates a legacy record returns the same snapshot twice", () => {+ const target = modelConfigTarget(REPO, {+ source: "hub",+ isLora: false,+ ggufVariant: QUANT,+ isDownloaded: true,+ isGguf: true,+ });+ const first = rememberedRunSettings(target);+ assert.equal(first?.kvCacheDtype, "q8_0");+ assert.ok(store.get("unsloth_model_configs"), "the first read migrated the record");+ assert.equal(rememberedRunSettings(target), first);+});diff --git a/studio/frontend/tests/remembered-run-settings.test.ts b/studio/frontend/tests/remembered-run-settings.test.tsnew file mode 100644index 00000000000..d99d55036ef--- /dev/null+++ b/studio/frontend/tests/remembered-run-settings.test.ts@@ -0,0 +1,568 @@+// 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,+ readSrcAsync,+ registerStoreStubResolver,+} from "./helpers/kit.ts";++registerStoreStubResolver();+const { store, storage, fireWindowEvent } = installLocalStorageFake();+Object.assign(globalThis.window, {+ dispatchEvent: (event: Event) => {+ fireWindowEvent(event.type, event);+ return true;+ },+});++const { forgetRunSettings, rememberedRunSettings, subscribeRememberedRunSettings } =+ await import(+ "../src/features/model-picker/model-config/remembered-run-settings.ts"+ );+const {+ DEFAULT_PER_MODEL_CONFIG,+ deletePerModelConfigsForOverrideKeys,+ perModelConfigSnapshot,+ resolveInitialConfig,+ savePerModelConfig,+} = await import("../src/features/model-picker/model-config/per-model-config.ts");+const { modelConfigTarget } = await import(+ "../src/features/model-picker/model-config/model-config-handoff.ts"+);+const {+ getPinnedRunSettings,+ getSelectedRunSettings,+ saveRunSettings,+ setPinnedRunSettings,+ setSelectedRunSettings,+} = await import(+ "../src/features/model-picker/model-config/saved-run-settings.ts"+);+const { setAuthFetchHandler } = await import("./helpers/store-stubs/auth.ts");++const REPO = "unsloth/gemma-4-12B-it-qat-GGUF";+const QUANT = "UD-Q4_K_XL";++const ggufTarget = () =>+ modelConfigTarget(REPO, {+ source: "hub",+ isLora: false,+ ggufVariant: QUANT,+ isDownloaded: true,+ isGguf: true,+ });++const tuned = () => ({+ ...DEFAULT_PER_MODEL_CONFIG,+ kvCacheDtype: "q8_0",+ nParallel: 4,+});++function captureOverridePuts(): { modelKey: string; body: unknown }[] {+ const puts: { modelKey: string; body: unknown }[] = [];+ setAuthFetchHandler((_input, init) => {+ const body = JSON.parse(String(init?.body ?? "{}"));+ puts.push({ modelKey: body.model_key ?? body.key ?? "", body });+ return new Response(JSON.stringify({ overrides: {}, removed_keys: [] }), {+ status: 200,+ headers: { "content-type": "application/json" },+ });+ });+ return puts;+}++test("a model with nothing saved reports none", () => {+ store.clear();+ assert.equal(rememberedRunSettings(ggufTarget()), null);+});++test("saving without loading is what the row reads back", () => {+ store.clear();+ assert.ok(savePerModelConfig(REPO, QUANT, tuned()));+ assert.equal(rememberedRunSettings(ggufTarget())?.kvCacheDtype, "q8_0");+ // Another quant of the same repo keeps its own answer.+ const other = modelConfigTarget(REPO, {+ source: "hub",+ isLora: false,+ ggufVariant: "Q8_0",+ isGguf: true,+ });+ assert.equal(rememberedRunSettings(other), null);+});++test("a subscribed reader sees a save without remounting", () => {+ store.clear();+ let changes = 0;+ const stop = subscribeRememberedRunSettings(() => {+ changes += 1;+ });+ try {+ assert.equal(rememberedRunSettings(ggufTarget()), null);+ savePerModelConfig(REPO, QUANT, tuned());+ assert.ok(changes > 0, "a save must notify subscribers");+ assert.equal(rememberedRunSettings(ggufTarget())?.nParallel, 4);+ } finally {+ stop();+ }+});++test("forget drops the saved settings and undo restores the same values", async () => {+ store.clear();+ const puts = captureOverridePuts();+ try {+ savePerModelConfig(REPO, QUANT, tuned());+ const undo = forgetRunSettings(ggufTarget());+ assert.ok(+ undo,+ "forget returns an undo when there was something to forget",+ );+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, false);++ assert.equal(undo(), true);+ const restored = resolveInitialConfig(REPO, QUANT);+ assert.equal(restored.remembered, true);+ assert.equal(restored.config.kvCacheDtype, "q8_0");+ assert.equal(restored.config.nParallel, 4);++ // GGUF is API-loadable, so both the forget and the undo reach the server mirror.+ await new Promise((resolve) => setTimeout(resolve, 0));+ assert.equal(puts.length, 2);+ } finally {+ setAuthFetchHandler(null);+ }+});++test("forget puts a selected and pinned set back on Default, and undo restores both", async () => {+ store.clear();+ captureOverridePuts();+ try {+ saveRunSettings(REPO, "fast", tuned());+ savePerModelConfig(REPO, QUANT, tuned());+ setSelectedRunSettings(REPO, QUANT, "fast");+ setPinnedRunSettings(REPO, QUANT, "fast");+ const undo = forgetRunSettings(ggufTarget());+ assert.ok(undo);+ assert.equal(getSelectedRunSettings(REPO, QUANT), null);+ assert.equal(getPinnedRunSettings(REPO, QUANT), null);++ assert.equal(undo(), true);+ assert.equal(getSelectedRunSettings(REPO, QUANT), "fast");+ assert.equal(getPinnedRunSettings(REPO, QUANT), "fast");+ await new Promise((resolve) => setTimeout(resolve, 0));+ } finally {+ setAuthFetchHandler(null);+ }+});++test("forget leaves a never-chosen selection unchosen", async () => {+ store.clear();+ captureOverridePuts();+ try {+ savePerModelConfig(REPO, QUANT, tuned());+ const undo = forgetRunSettings(ggufTarget());+ assert.ok(undo);+ assert.equal(getSelectedRunSettings(REPO, QUANT), undefined);+ assert.equal(undo(), true);+ assert.equal(getSelectedRunSettings(REPO, QUANT), undefined);+ await new Promise((resolve) => setTimeout(resolve, 0));+ } finally {+ setAuthFetchHandler(null);+ }+});++test("undo leaves settings saved after the reset alone", async () => {+ store.clear();+ const puts = captureOverridePuts();+ try {+ savePerModelConfig(REPO, QUANT, tuned());+ const undo = forgetRunSettings(ggufTarget());+ assert.ok(undo);+ savePerModelConfig(REPO, QUANT, {+ ...DEFAULT_PER_MODEL_CONFIG,+ kvCacheDtype: "q4_0",+ });+ assert.equal(undo(), false);+ assert.equal(resolveInitialConfig(REPO, QUANT).config.kvCacheDtype, "q4_0");+ await new Promise((resolve) => setTimeout(resolve, 0));+ assert.equal(puts.length, 1);+ } finally {+ setAuthFetchHandler(null);+ }+});++test("the reset in Settings > General clears the write stamps too", async () => {+ const stampsKey = /WRITE_STAMPS_KEY = "([^"]+)"/.exec(+ await readSrcAsync(+ "features/model-picker/model-config/per-model-config.ts",+ ),+ )?.[1];+ assert.ok(stampsKey);+ const source = await readSrcAsync("features/settings/tabs/general-tab.tsx");+ const start = source.indexOf("const PREFS_KEYS");+ assert.ok(+ source.slice(start, source.indexOf("];", start)).includes(`"${stampsKey}"`),+ );+});++test("forget with nothing saved does nothing", () => {+ store.clear();+ assert.equal(forgetRunSettings(ggufTarget()), null);+});++test("forget marks a mounted editor's draft unsaved, and undo marks it saved again", async () => {+ store.clear();+ const {+ modelConfigDraftKey,+ primeModelConfigDraft,+ readModelConfigDraft,+ retainModelConfigDraft,+ } = await import(+ "../src/features/model-picker/model-config/model-config-draft.ts"+ );+ setAuthFetchHandler(() => new Response("{}", { status: 200 }));+ const key = modelConfigDraftKey(REPO, QUANT);+ // The sidebar keeps the loaded model's editor mounted, so its draft outlives the picker.+ const release = retainModelConfigDraft(key);+ try {+ savePerModelConfig(REPO, QUANT, tuned());+ primeModelConfigDraft(key, { config: tuned(), remembered: true }, "none");+ const undo = forgetRunSettings(ggufTarget());+ assert.ok(undo);+ assert.equal(readModelConfigDraft(key)?.savedRemember, false);+ assert.equal(readModelConfigDraft(key)?.remember, false);+ // The editor keeps showing what is loaded; only the saved flags change.+ assert.equal(readModelConfigDraft(key)?.config.kvCacheDtype, "q8_0");+ assert.equal(undo(), true);+ assert.equal(readModelConfigDraft(key)?.savedRemember, true);+ assert.equal(readModelConfigDraft(key)?.remember, true);+ } finally {+ release();+ setAuthFetchHandler(null);+ }+});++test("undo restores an editor opened after the reset, so its next load keeps the settings", async () => {+ store.clear();+ const {+ isModelConfigDraftEdited,+ modelConfigDraftKey,+ primeModelConfigDraft,+ readModelConfigDraft,+ retainModelConfigDraft,+ } = await import(+ "../src/features/model-picker/model-config/model-config-draft.ts"+ );+ setAuthFetchHandler(() => new Response("{}", { status: 200 }));+ const key = modelConfigDraftKey(REPO, QUANT);+ let release: (() => void) | null = null;+ try {+ savePerModelConfig(REPO, QUANT, tuned());+ const undo = forgetRunSettings(ggufTarget());+ assert.ok(undo);+ // The panel opens inside the toast's window and seeds from what is stored now: defaults.+ release = retainModelConfigDraft(key);+ primeModelConfigDraft(key, resolveInitialConfig(REPO, QUANT), "none");+ assert.equal(readModelConfigDraft(key)?.remember, false);+ assert.equal(undo(), true);+ assert.equal(readModelConfigDraft(key)?.remember, true);+ assert.equal(readModelConfigDraft(key)?.savedRemember, true);+ assert.equal(readModelConfigDraft(key)?.config.kvCacheDtype, "q8_0");+ assert.equal(isModelConfigDraftEdited(key), false);+ } finally {+ release?.();+ setAuthFetchHandler(null);+ }+});++test("an undo before the forget's response keeps the restored record", async () => {+ store.clear();+ const pending: { release?: () => void } = {};+ setAuthFetchHandler((_input, init) => {+ const body = JSON.parse(String(init?.body ?? "{}"));+ const response = () =>+ new Response(+ JSON.stringify({+ overrides: {},+ // biome-ignore lint/style/useNamingConvention: API schema+ removed_keys: body.remove ? [`${REPO}:${QUANT}`] : [],+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ );+ if (!body.remove) {+ return response();+ }+ return new Promise<Response>((resolve) => {+ pending.release = () => resolve(response());+ });+ });+ try {+ savePerModelConfig(REPO, QUANT, tuned());+ const undo = forgetRunSettings(ggufTarget());+ assert.ok(undo);+ assert.equal(undo(), true);+ await new Promise((resolve) => setTimeout(resolve, 0));+ assert.ok(pending.release, "the forget is still in flight");+ pending.release();+ await new Promise((resolve) => setTimeout(resolve, 0));+ const restored = resolveInitialConfig(REPO, QUANT);+ assert.equal(restored.remembered, true);+ assert.equal(restored.config.nParallel, 4);+ } finally {+ setAuthFetchHandler(null);+ }+});++test("a save under another alias before the forget's response keeps that record", async () => {+ store.clear();+ const { syncModelOverride } = await import(+ "../src/features/model-picker/api/model-overrides.ts"+ );+ // The loaded sidebar keys a cached GGUF by its snapshot path; the forget clears both spellings.+ const SNAPSHOT = "C:/hf/models--unsloth--gemma-4-12B-it-qat-GGUF/snapshots/abc123";+ const pending: { release?: () => void } = {};+ setAuthFetchHandler((_input, init) => {+ const body = JSON.parse(String(init?.body ?? "{}"));+ const response = () =>+ new Response(+ JSON.stringify({+ overrides: {},+ // biome-ignore lint/style/useNamingConvention: API schema+ removed_keys: body.remove ? [`${REPO}:${QUANT}`, `${SNAPSHOT}:${QUANT}`] : [],+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ );+ if (!body.remove) {+ return response();+ }+ return new Promise<Response>((resolve) => {+ pending.release = () => resolve(response());+ });+ });+ try {+ savePerModelConfig(REPO, QUANT, tuned());+ assert.ok(forgetRunSettings(ggufTarget()));+ assert.ok(savePerModelConfig(SNAPSHOT, QUANT, tuned()));+ syncModelOverride(SNAPSHOT, QUANT, tuned());+ await new Promise((resolve) => setTimeout(resolve, 0));+ assert.ok(pending.release, "the forget is still in flight");+ pending.release();+ await new Promise((resolve) => setTimeout(resolve, 0));+ assert.equal(resolveInitialConfig(SNAPSHOT, QUANT).remembered, true);+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, false);+ } finally {+ setAuthFetchHandler(null);+ }+});++test("a save from another tab before the forget's response keeps that record", async () => {+ store.clear();+ const SNAPSHOT = "C:/hf/models--unsloth--gemma-4-12B-it-qat-GGUF/snapshots/abc123";+ const pending: { release?: () => void } = {};+ setAuthFetchHandler((_input, init) => {+ const body = JSON.parse(String(init?.body ?? "{}"));+ const response = () =>+ new Response(+ JSON.stringify({+ overrides: {},+ // biome-ignore lint/style/useNamingConvention: API schema+ removed_keys: body.remove ? [`${REPO}:${QUANT}`, `${SNAPSHOT}:${QUANT}`] : [],+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ );+ if (!body.remove) {+ return response();+ }+ return new Promise<Response>((resolve) => {+ pending.release = () => resolve(response());+ });+ });+ try {+ savePerModelConfig(REPO, QUANT, tuned());+ // An older copy under the alias, as the forget will find and clear it.+ savePerModelConfig(SNAPSHOT, QUANT, { ...tuned(), nParallel: 2 });+ assert.ok(forgetRunSettings(ggufTarget()));+ // The other tab writes the shared localStorage directly; this tab's module never sees it.+ assert.ok(savePerModelConfig(SNAPSHOT, QUANT, tuned()));+ await new Promise((resolve) => setTimeout(resolve, 0));+ assert.ok(pending.release, "the forget is still in flight");+ pending.release();+ await new Promise((resolve) => setTimeout(resolve, 0));+ assert.equal(resolveInitialConfig(SNAPSHOT, QUANT).config.nParallel, 4);+ assert.equal(resolveInitialConfig(SNAPSHOT, QUANT).remembered, true);+ } finally {+ setAuthFetchHandler(null);+ }+});++test("an unchanged alias is still cleared when the forget's response lands", async () => {+ store.clear();+ const SNAPSHOT = "C:/hf/models--unsloth--gemma-4-12B-it-qat-GGUF/snapshots/abc123";+ setAuthFetchHandler((_input, init) => {+ const body = JSON.parse(String(init?.body ?? "{}"));+ return new Response(+ JSON.stringify({+ overrides: {},+ // biome-ignore lint/style/useNamingConvention: API schema+ removed_keys: body.remove ? [`${REPO}:${QUANT}`, `${SNAPSHOT}:${QUANT}`] : [],+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ );+ });+ try {+ savePerModelConfig(REPO, QUANT, tuned());+ savePerModelConfig(SNAPSHOT, QUANT, tuned());+ assert.ok(forgetRunSettings(ggufTarget()));+ await new Promise((resolve) => setTimeout(resolve, 0));+ await new Promise((resolve) => setTimeout(resolve, 0));+ assert.equal(resolveInitialConfig(SNAPSHOT, QUANT).remembered, false);+ } finally {+ setAuthFetchHandler(null);+ }+});++test("an identical re-save from another tab before the forget's response keeps that record", async () => {+ store.clear();+ const SNAPSHOT = "C:/hf/models--unsloth--gemma-4-12B-it-qat-GGUF/snapshots/abc123";+ const pending: { release?: () => void } = {};+ setAuthFetchHandler((_input, init) => {+ const body = JSON.parse(String(init?.body ?? "{}"));+ const response = () =>+ new Response(+ JSON.stringify({+ overrides: {},+ // biome-ignore lint/style/useNamingConvention: API schema+ removed_keys: body.remove ? [`${REPO}:${QUANT}`, `${SNAPSHOT}:${QUANT}`] : [],+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ );+ if (!body.remove) {+ return response();+ }+ return new Promise<Response>((resolve) => {+ pending.release = () => resolve(response());+ });+ });+ try {+ savePerModelConfig(REPO, QUANT, tuned());+ savePerModelConfig(SNAPSHOT, QUANT, tuned());+ assert.ok(forgetRunSettings(ggufTarget()));+ // Same settings, saved again by the other tab: only the write itself is new.+ assert.ok(savePerModelConfig(SNAPSHOT, QUANT, tuned()));+ await new Promise((resolve) => setTimeout(resolve, 0));+ assert.ok(pending.release, "the forget is still in flight");+ pending.release();+ await new Promise((resolve) => setTimeout(resolve, 0));+ assert.equal(resolveInitialConfig(SNAPSHOT, QUANT).remembered, true);+ } finally {+ setAuthFetchHandler(null);+ }+});++test("a forget's cleanup between another tab's two writes keeps an identical re-save", () => {+ store.clear();+ savePerModelConfig(REPO, QUANT, tuned());+ const snapshot = perModelConfigSnapshot();+ const setItem = storage.setItem;+ let cleaned = false;+ // The cleanup lands right after the re-save's first write, before its second.+ storage.setItem = (key: string, value: string) => {+ setItem(key, value);+ if (!cleaned) {+ cleaned = true;+ deletePerModelConfigsForOverrideKeys([`${REPO}:${QUANT}`], snapshot);+ }+ };+ try {+ assert.ok(savePerModelConfig(REPO, QUANT, tuned()));+ } finally {+ storage.setItem = setItem;+ }+ assert.ok(cleaned);+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, true);+});++/** Run `save` once, right after the `nth` storage read (of `onlyKey`, if given) inside `read`. */+function saveBetweenReads<T>(+ read: () => T,+ save: () => void,+ nth = 1,+ onlyKey?: string,+): T {+ const getItem = storage.getItem;+ let saved = false;+ let reads = 0;+ storage.getItem = (key: string) => {+ const value = getItem(key);+ if (!onlyKey || key === onlyKey) {+ reads += 1;+ }+ if (!saved && reads === nth) {+ saved = true;+ storage.getItem = getItem;+ save();+ }+ return value;+ };+ try {+ return read();+ } finally {+ storage.getItem = getItem;+ }+}++test("an identical save between the forget snapshot's two reads is kept", () => {+ store.clear();+ savePerModelConfig(REPO, QUANT, tuned());+ const snapshot = saveBetweenReads(perModelConfigSnapshot, () =>+ assert.ok(savePerModelConfig(REPO, QUANT, tuned())),+ );+ deletePerModelConfigsForOverrideKeys([`${REPO}:${QUANT}`], snapshot);+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, true);+});++test("an identical save between the cleanup's two reads is kept", () => {+ store.clear();+ savePerModelConfig(REPO, QUANT, tuned());+ const snapshot = perModelConfigSnapshot();+ saveBetweenReads(+ () => deletePerModelConfigsForOverrideKeys([`${REPO}:${QUANT}`], snapshot),+ () => assert.ok(savePerModelConfig(REPO, QUANT, tuned())),+ );+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, true);+});++test("an identical save after the cleanup listed its owners is kept", () => {+ store.clear();+ savePerModelConfig(REPO, QUANT, tuned());+ const snapshot = perModelConfigSnapshot();+ // The second read of the record map: the save lands after the owners were listed.+ saveBetweenReads(+ () => deletePerModelConfigsForOverrideKeys([`${REPO}:${QUANT}`], snapshot),+ () => assert.ok(savePerModelConfig(REPO, QUANT, tuned())),+ 2,+ "unsloth_model_configs",+ );+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, true);+});++test("an unsubscribed read returns the same snapshot until the store changes", () => {+ store.clear();+ savePerModelConfig(REPO, QUANT, tuned());+ const first = rememberedRunSettings(ggufTarget());+ assert.ok(first);+ // useSyncExternalStore reads before it subscribes, and needs the same object back.+ assert.equal(rememberedRunSettings(ggufTarget()), first);+ savePerModelConfig(REPO, QUANT, { ...tuned(), nParallel: 8 });+ assert.equal(rememberedRunSettings(ggufTarget())?.nParallel, 8);+ const stop = subscribeRememberedRunSettings(() => {});+ try {+ const subscribed = rememberedRunSettings(ggufTarget());+ assert.equal(rememberedRunSettings(ggufTarget()), subscribed);+ } finally {+ stop();+ }+});diff --git a/tests/studio/playwright_model_config.py b/tests/studio/playwright_model_config.pyindex be7d5afd8db..06fa75ff809 100644--- a/tests/studio/playwright_model_config.py+++ b/tests/studio/playwright_model_config.py@@ -831,9 +831,9 @@ with sync_playwright() as p:# 3. Reset clears the override (never pins context) (HARD).step("reset clears the per-model override", LOAD_STEP_BUDGET_S)- reset_btn = popover.get_by_role("button", name = "Reset").first+ reset_btn = popover.get_by_role("button", name = "Reset all", exact = True).firstif _count(reset_btn) == 0:- fail("Reset button not found in run-settings")+ fail("Reset all button not found in run-settings")else:try:reset_btn.click()diff --git a/tests/studio/test_model_picker_contracts.py b/tests/studio/test_model_picker_contracts.pyindex 0501280d7eb..c9060d2187a 100644--- a/tests/studio/test_model_picker_contracts.py+++ b/tests/studio/test_model_picker_contracts.py@@ -2792,8 +2792,12 @@ def test_override_writes_are_ordered_per_model():"const key = modelOverrideKey( normalizeModelIdentity(modelId), normalizeGgufVariantIdentity(ggufVariant), );"in src)- # Chained on the settled tail, so one failed write cannot cancel the next.- assert "previous .catch(() => {}) .then(() => sendModelOverride(" in src+ # Chained on the settled tails (allSettled), so one failed write cannot cancel the next.+ assert "Promise.allSettled([forgetBarrier, writesByKey.get(key)])" in src+ # A forget clears every alias on the server, so it waits on every key's tail, not just its own.+ assert "Promise.allSettled([forgetBarrier, ...writesByKey.values()])" in src+ assert "const write = previous.then(() => sendModelOverride(" in src+ # The tail is stored, or every writer chains on the same empty slot.assert "writesByKey.set(key, write);" in src# Only the last writer clears the slot, or a queue still building loses order.assert "if (writesByKey.get(key) === write) { writesByKey.delete(key); }" in src@@ -3233,10 +3237,10 @@ def test_run_settings_page_keeps_its_identifying_controls():# else Default settings, which fills the panel with DEFAULT_PER_MODEL_CONFIG.reset = any("onClick={() => pickSet(pinnedSet)}" in el.group(0)- and re.search(r">\s*Reset\s*<", el.group(0))+ and re.search(r">\s*Reset all\s*<", el.group(0))for el in re.finditer(r"<Button\b.*?</Button>", page, re.S))- assert reset, "the Reset button's JSX is gone or no longer named Reset"+ assert reset, "the Reset all button's JSX is gone or no longer named Reset all"assert "const next = entry?.config ?? DEFAULT_PER_MODEL_CONFIG;" in page@@ -3903,3 +3907,25 @@ def test_a_download_only_pick_is_allowed_while_the_page_is_busy():text = body.group(1)assert "if (busy !== null && !downloadOnlyPick) return;" in textassert text.index("const downloadOnlyPick =") < text.index("if (busy !== null")+++def test_every_run_settings_gear_marks_saved_settings():+ # A gear that opens run settings but skips savedFor saves settings the row never shows.+ picker = _read("features/model-picker/components/model-selector/pickers.tsx")+ gears = [m.group(0) for m in re.finditer(r"<ModelLoadSettingsAction\b.*?/>", picker, re.S)]+ run_settings = [g for g in gears if "onConfigure(" in g or ".configure(" in g]+ assert len(run_settings) >= 10, "the run-settings gears moved; update this guard"+ missing = [g.splitlines()[1].strip() for g in run_settings if "savedFor=" not in g]+ assert not missing, f"run-settings gears without savedFor: {missing}"+++def test_a_quant_saved_before_download_still_offers_reset():+ # The gear saves settings on a quant that is not on disk yet; such a row has no other menu.+ picker = _read("features/model-picker/components/model-selector/pickers.tsx")+ gate = re.search(r"function SavedRunSettingsMenu\(.*?\n}\n", picker, re.S)+ assert gate, "the saved-only Reset menu was renamed"+ assert "useHasRememberedRunSettings(runSettings ?? null)" in gate.group(0)+ assert re.search(+ r"!variantHasMenu\(v\) && \(\s*<SavedRunSettingsMenu[^/]*runSettings=\{configTarget\}",+ picker,+ ), "a quant row without a menu lost its Reset"