+
setTemplateOpen(true)}
layerCount={stagedDims?.layerCount ?? null}
moeLayerCount={stagedDims?.moeLayerCount ?? null}
+ gpuLayersInputRef={gpuLayersInputRef}
+ moeLayersInputRef={moeLayersInputRef}
/>
)}
@@ -914,6 +1019,7 @@ export function ModelConfigPage({
value={maxSeqLengthValue}
max={maxSeqLengthMax}
inputMax={MAX_SEQ_LENGTH_MAX}
+ inputRef={maxSeqLengthInputRef}
onChange={(value) =>
update({
maxSeqLength: clampMaxSeqLength(value, MAX_SEQ_LENGTH_MAX),
diff --git a/studio/frontend/src/features/model-picker/components/numeric-value-input.tsx b/studio/frontend/src/features/model-picker/components/numeric-value-input.tsx
index 2489927fc2..be9aa7745c 100644
--- a/studio/frontend/src/features/model-picker/components/numeric-value-input.tsx
+++ b/studio/frontend/src/features/model-picker/components/numeric-value-input.tsx
@@ -2,7 +2,13 @@
// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
import { cn } from "@/lib/utils";
-import { useRef, useState } from "react";
+import {
+ forwardRef,
+ useEffect,
+ useImperativeHandle,
+ useRef,
+ useState,
+} from "react";
export function snapToStep(
value: number,
@@ -28,44 +34,109 @@ function sanitizeNumeric(raw: string, allowNegative: boolean): string {
return `${sign}${head}${tail}`;
}
-export function NumericValueInput({
- value,
- min,
- max,
- step,
- onChange,
- displayValue,
- className,
- ariaLabel,
- size: sizeAttr,
- disabled = false,
-}: {
- value: number;
- min?: number;
- max?: number;
- step: number;
- onChange: (v: number) => void;
- displayValue?: string;
- className?: string;
- ariaLabel?: string;
- size?: number;
- disabled?: boolean;
-}) {
+export type NumericValueInputHandle = {
+ /** Commit a valid focused/same-click draft; null when none is pending. */
+ commit: () => number | null;
+};
+
+export const NumericValueInput = forwardRef<
+ NumericValueInputHandle,
+ {
+ value: number;
+ min?: number;
+ max?: number;
+ step: number;
+ onChange: (v: number) => void;
+ displayValue?: string;
+ className?: string;
+ ariaLabel?: string;
+ size?: number;
+ disabled?: boolean;
+ }
+>(function NumericValueInput(
+ {
+ value,
+ min,
+ max,
+ step,
+ onChange,
+ displayValue,
+ className,
+ ariaLabel,
+ size: sizeAttr,
+ disabled = false,
+ },
+ ref,
+) {
const [focused, setFocused] = useState(false);
const [draft, setDraft] = useState("");
const cancelBlurCommitRef = useRef(false);
+ const draftRef = useRef("");
+ const dirtyRef = useRef(false);
+ // Same-click Load: blur commits via onChange and clears dirtyRef before the
+ // button onClick runs, while parent `value` is still stale. Keep the blur
+ // result for one imperative commit(); clear when `value` catches up or on
+ // focus / external edits (Reset, slider).
+ const lastBlurCommittedRef = useRef(null);
- const commit = (raw: string) => {
+ // The blur bridge is only valid across the single synchronous gesture that set
+ // it: blur commits during a button's mousedown and that button's onClick
+ // consumes it via commit() before React re-renders. Any settled render means the
+ // gesture is over, so drop the cache on every commit. Keying this on [value]
+ // alone missed a Reset (or other external edit) that restores the shown value
+ // unchanged when the blur did dispatch onChange (final !== value): value nets
+ // back to its prior number, so the effect never re-ran, the stale pin survived,
+ // and the next Load/Save replayed the override Reset had removed.
+ useEffect(() => {
+ lastBlurCommittedRef.current = null;
+ });
+
+ const commitDraft = (raw: string): number | null => {
const parsed = Number.parseFloat(raw);
if (!Number.isFinite(parsed)) {
- return;
+ return null;
}
const final = snapToStep(parsed, step, min, max);
if (final !== value) {
onChange(final);
}
+ return final;
};
+ useImperativeHandle(
+ ref,
+ () => ({
+ commit: () => {
+ if (dirtyRef.current) {
+ const raw = draftRef.current;
+ const final = commitDraft(raw);
+ dirtyRef.current = false;
+ lastBlurCommittedRef.current = null;
+ if (final == null) {
+ draftRef.current = String(value);
+ }
+ if (focused) {
+ setFocused(false);
+ }
+ return final;
+ }
+ const blurCommitted = lastBlurCommittedRef.current;
+ if (blurCommitted != null) {
+ lastBlurCommittedRef.current = null;
+ if (focused) {
+ setFocused(false);
+ }
+ return blurCommitted;
+ }
+ if (focused) {
+ setFocused(false);
+ }
+ return null;
+ },
+ }),
+ [draft, focused, max, min, onChange, step, value],
+ );
+
const displayed = focused ? draft : (displayValue ?? String(value));
return (
@@ -82,7 +153,11 @@ export function NumericValueInput({
aria-label={ariaLabel}
onFocus={(e) => {
cancelBlurCommitRef.current = false;
- setDraft(String(value));
+ dirtyRef.current = false;
+ lastBlurCommittedRef.current = null;
+ const next = String(value);
+ draftRef.current = next;
+ setDraft(next);
setFocused(true);
const target = e.currentTarget;
requestAnimationFrame(() => target.select());
@@ -90,24 +165,47 @@ export function NumericValueInput({
onBlur={() => {
if (cancelBlurCommitRef.current) {
cancelBlurCommitRef.current = false;
- } else {
- commit(draft);
+ lastBlurCommittedRef.current = null;
+ } else if (dirtyRef.current) {
+ const final = commitDraft(draftRef.current);
+ dirtyRef.current = false;
+ if (final == null) {
+ draftRef.current = String(value);
+ lastBlurCommittedRef.current = null;
+ } else {
+ draftRef.current = String(final);
+ // Only bridge the still-stale parent value when the blur actually
+ // dispatched onChange (final !== value). When final === value the
+ // parent is already current, so there is nothing to bridge; caching
+ // here would leave a stale pin that a later Reset or external edit
+ // (which doesn't change the displayed value) can never clear, so a
+ // following Load/Save would recreate the override Reset removed.
+ lastBlurCommittedRef.current = final !== value ? final : null;
+ }
}
setFocused(false);
}}
- onChange={(e) =>
- setDraft(sanitizeNumeric(e.target.value, (min ?? 0) < 0))
- }
+ onChange={(e) => {
+ dirtyRef.current = true;
+ lastBlurCommittedRef.current = null;
+ const next = sanitizeNumeric(e.target.value, (min ?? 0) < 0);
+ draftRef.current = next;
+ setDraft(next);
+ }}
onKeyDown={(e) => {
if (e.key === "Enter") {
e.currentTarget.blur();
} else if (e.key === "Escape") {
cancelBlurCommitRef.current = true;
- setDraft(String(value));
+ dirtyRef.current = false;
+ lastBlurCommittedRef.current = null;
+ const next = String(value);
+ draftRef.current = next;
+ setDraft(next);
e.currentTarget.blur();
}
}}
className={cn(className)}
/>
);
-}
+});
diff --git a/studio/frontend/src/features/model-picker/index.ts b/studio/frontend/src/features/model-picker/index.ts
index d2b4785ec3..383d441f09 100644
--- a/studio/frontend/src/features/model-picker/index.ts
+++ b/studio/frontend/src/features/model-picker/index.ts
@@ -12,6 +12,7 @@ export {
export { hfModelFitsDevice } from "./components/model-selector/recommended-fit";
export {
NumericValueInput,
+ type NumericValueInputHandle,
snapToStep,
} from "./components/numeric-value-input";
export { SidebarModelConfig } from "./components/sidebar-model-config";
diff --git a/tests/studio/playwright_model_config.py b/tests/studio/playwright_model_config.py
index a8d143a253..d72dc37955 100644
--- a/tests/studio/playwright_model_config.py
+++ b/tests/studio/playwright_model_config.py
@@ -70,6 +70,8 @@ ART_DIR = os.environ.get("PW_ART_DIR", "logs/playwright_modelcfg")
ART = Path(ART_DIR)
ART.mkdir(parents = True, exist_ok = True)
STRICT = os.environ.get("STUDIO_UI_STRICT", "0") == "1"
+PLAYWRIGHT_BROWSER = os.environ.get("STUDIO_PLAYWRIGHT_BROWSER", "chromium").lower()
+PLAYWRIGHT_CHANNEL = os.environ.get("STUDIO_PLAYWRIGHT_CHANNEL") or None
TURN_TIMEOUT_MS = int(os.environ.get("STUDIO_UI_TURN_TIMEOUT_MS", "180000"))
WALL_TIMEOUT_S = float(os.environ.get("STUDIO_UI_WALL_TIMEOUT_S", "720"))
FETCH_TIMEOUT_MS = int(os.environ.get("STUDIO_UI_FETCH_TIMEOUT_MS", "30000"))
@@ -145,10 +147,19 @@ with sync_playwright() as p:
)
# Health pre-flight: bash-side health wait can pass before the auth DB migrates.
wait_for_health(BASE, timeout = 30.0, info = info)
- browser = p.chromium.launch(
- headless = True,
- args = chromium_launch_args(),
- )
+ if PLAYWRIGHT_BROWSER not in ("chromium", "firefox", "webkit"):
+ fail(f"unsupported STUDIO_PLAYWRIGHT_BROWSER={PLAYWRIGHT_BROWSER!r}")
+ sys.exit(1)
+ browser_type = getattr(p, PLAYWRIGHT_BROWSER)
+ launch_kwargs = {"headless": True}
+ if PLAYWRIGHT_BROWSER == "chromium":
+ launch_kwargs["args"] = chromium_launch_args()
+ if PLAYWRIGHT_CHANNEL:
+ launch_kwargs["channel"] = PLAYWRIGHT_CHANNEL
+ elif PLAYWRIGHT_CHANNEL:
+ fail("STUDIO_PLAYWRIGHT_CHANNEL requires chromium")
+ sys.exit(1)
+ browser = browser_type.launch(**launch_kwargs)
ctx = browser.new_context(
viewport = {"width": 1280, "height": 900},
reduced_motion = "reduce",
@@ -464,11 +475,6 @@ with sync_playwright() as p:
else:
default_ctx = ctx_in.input_value()
info(f"default Context Length shown: {default_ctx!r}")
- ctx_in.click()
- ctx_in.fill(str(DISTINCT_CTX))
- page.wait_for_timeout(300)
- page.keyboard.press("Tab") # blur to commit
- page.wait_for_timeout(300)
remember = popover.get_by_label("Remember for this model").first
if _count(remember):
try:
@@ -477,12 +483,16 @@ with sync_playwright() as p:
remember.click()
else:
fail("'Remember for this model' checkbox not found")
+ ctx_in.click()
+ ctx_in.fill(str(DISTINCT_CTX))
page.wait_for_timeout(300)
shoot("05-ctx-set")
btn = primary_button(popover)
if btn is None:
fail("primary Load/Save button not found in run-settings")
else:
+ # Keep the input focused. The button click must commit the draft
+ # and use it in the same load request.
btn.click()
page.wait_for_timeout(2500)
shoot("06-after-load")
@@ -570,6 +580,47 @@ with sync_playwright() as p:
else:
info("OK reset: distinctive context cleared from unsloth_model_configs")
shoot("08-after-reset")
+
+ # ─────────────────────────────────────────────────────
+ # 3b. Re-typing the value already shown must not pin an override (HARD).
+ # Entering the currently displayed native/default context commits no
+ # onChange (the value is unchanged), so the cached blur value must not be
+ # replayed into a stored override on Load. Otherwise re-typing the shown
+ # number, or doing so before a Reset, recreates a phantom context pin.
+ # ─────────────────────────────────────────────────────
+ step("re-typing the shown context does not pin an override")
+ ctx_in = context_input(popover)
+ native_default = _as_int(ctx_in.input_value()) if ctx_in else None
+ if ctx_in is None or native_default is None:
+ info("skip re-type-shown: Context Length input has no numeric default")
+ else:
+ remember = popover.get_by_label("Remember for this model").first
+ if _count(remember):
+ try:
+ remember.check()
+ except Exception:
+ remember.click()
+ ctx_in.click()
+ ctx_in.fill(str(native_default))
+ page.wait_for_timeout(200)
+ btn = primary_button(popover)
+ if btn is not None and btn.is_enabled():
+ # Same-click Load: the button click must commit the draft, but a draft
+ # equal to the shown value carries no override.
+ btn.click()
+ page.wait_for_timeout(1500)
+ cfg = read_configs()
+ pinned = any(
+ _as_int(e.get("customContextLength")) == native_default for e in config_entries(cfg)
+ )
+ if pinned:
+ fail(
+ "re-typing the shown context pinned it as an override "
+ f"(customContextLength={native_default})"
+ )
+ else:
+ info("OK re-type-shown: shown context not stored as an override")
+ shoot("08b-after-retype-shown")
close_picker()
# ─────────────────────────────────────────────────────
diff --git a/tests/studio/test_model_picker_contracts.py b/tests/studio/test_model_picker_contracts.py
index 3934b72d83..815f68e010 100644
--- a/tests/studio/test_model_picker_contracts.py
+++ b/tests/studio/test_model_picker_contracts.py
@@ -346,6 +346,36 @@ def test_fixed_layer_gguf_pins_displayed_context():
assert "customContextLength: activeLoadedContext" in src
+def test_fixed_layer_pin_recomputed_after_committing_gpu_layers():
+ """pinFixedLayerContext is computed from the render-time config, before a
+ same-click GPU Layers draft is committed. handleRun must recompute it from the
+ committed effectiveConfig; otherwise typing a positive GPU Layers value on an
+ auto-fit GGUF and clicking Reload saves customContextLength: null, so a later
+ fresh load sends the native context with fixed layers (the OOM the pin avoids)."""
+ src = _read("features/model-picker/components/model-config-page.tsx")
+ assert "const effectivePinFixedLayerContext =" in src
+ assert 'effectiveConfig.gpuMemoryMode === "manual"' in src
+ assert "effectiveConfig.gpuLayers != null" in src
+ assert "effectiveConfig.customContextLength == null" in src
+ assert "{ ...effectiveConfig, customContextLength: activeLoadedContext }" in src
+
+
+def test_blur_cache_cleared_on_every_settled_render():
+ """The lastBlurCommittedRef bridge is valid only across the single synchronous
+ same-click gesture that set it. Keying its clear on [value] missed a Reset (or
+ external edit) that restores the shown value unchanged after the blur dispatched
+ onChange: value nets back to its prior number, the effect never re-ran, and a
+ later Load/Save replayed the override Reset removed. Clear it on every settled
+ render instead."""
+ src = _read("features/model-picker/components/numeric-value-input.tsx")
+ # The clearing effect must run on every commit, not be gated on [value] alone.
+ assert not re.search(r"lastBlurCommittedRef\.current = null;\s*\}, \[value\]\);", src)
+ assert re.search(
+ r"useEffect\(\(\) => \{\s*lastBlurCommittedRef\.current = null;\s*\}\);",
+ src,
+ )
+
+
def test_auto_defaults_not_persisted_as_overrides():
"""Auto GPU memory mode and Auto/default speculative type are follow-global
defaults; normalization must not persist them as per-model overrides, else a
@@ -382,15 +412,90 @@ def test_reset_persists_null_max_length_and_substitutes_only_for_load():
Reset) so isDefaultConfig can clear a remembered override; the concrete
fallback is substituted only into the load request, not the saved record."""
src = _read("features/model-picker/components/model-config-page.tsx")
- # Load-only substitution of the resolved value.
- assert "maxSeqLength: maxSeqLengthValue" in src
- assert "const loadConfig" in src
- # The persisted record is loaded via onRun(loadConfig), and save uses the
- # untouched runtimeConfig (so a reset/default config stays default).
- assert "onRun(loadConfig)" in src
+ # Load-only substitution of the resolved value (recomputed from any committed
+ # same-click Max Seq Length draft, so it is never dropped).
+ assert "maxSeqLength: effectiveMaxSeqLengthValue" in src
+ assert "const effectiveLoadConfig" in src
+ # The persisted record is saved from effectiveRuntimeConfig; the load request
+ # carries effectiveLoadConfig (with any committed context input).
+ assert "onRun(effectiveLoadConfig)" in src
assert "savePerModelConfig(" in src
+def test_initial_load_uses_staged_config_payload():
+ """Run-settings Load must pass the staged config through to /load even when
+ React has not flushed NumericValueInput blur commits into the store yet."""
+ runtime = _read("features/chat/hooks/use-chat-model-runtime.ts")
+ assert "const pendingLoadConfig =" in runtime
+ assert "pendingLoadConfig?.kvCacheDtype" in runtime
+ assert "pendingLoadConfig?.customContextLength" in runtime
+ page = _read("features/model-picker/components/model-config-page.tsx")
+ assert "contextInputRef" in page
+ assert "contextInputRef.current?.commit()" in page
+ numeric = _read("features/model-picker/components/numeric-value-input.tsx")
+ assert "export type NumericValueInputHandle" in numeric
+ assert "commit:" in numeric
+ # P1: commit returns null unless the user actually edited the field,
+ # so Load/Save with untouched Auto does not pin native context.
+ assert "dirtyRef.current" in numeric
+ assert "return null;" in numeric
+ # P2: blur clears dirtyRef after commit so Reset/slider cannot be
+ # overwritten by a stale draft on a later Load.
+ assert "dirtyRef.current = false;" in numeric
+ assert "draftRef.current = String(final);" in numeric
+ # Same-click Load after blur still sees the committed draft.
+ assert "lastBlurCommittedRef" in numeric
+ # Invalid drafts must not turn Auto into an explicit pin.
+ assert "const commitDraft = (raw: string): number | null" in numeric
+ assert re.search(r"if \(!Number\.isFinite\(parsed\)\) \{\s*return null;", numeric)
+ assert re.search(
+ r"if \(final == null\) \{\s*"
+ r"draftRef\.current = String\(value\);\s*"
+ r"lastBlurCommittedRef\.current = null;",
+ numeric,
+ )
+ # handleRun only promotes commit() when non-null.
+ assert "committedContext != null" in page
+ assert "pendingPatch.customContextLength = committedContext;" in page
+
+
+def test_same_click_commit_covers_all_numeric_inputs():
+ """The same-click blur bridge must flush every NumericValueInput-backed
+ setting, not just Context Length. Max Seq Length (non-GGUF), GPU Layers and
+ MoE Layers (GGUF) also stage their draft only on blur, so handleRun must
+ imperatively commit each and fold the value into the staged load config;
+ otherwise a value the user typed right before clicking Load/Reload is lost."""
+ page = _read("features/model-picker/components/model-config-page.tsx")
+ # Each numeric input owns an imperative handle that handleRun commits, and the
+ # handle is forwarded down to the actual NumericValueInput.
+ for ref in ("maxSeqLengthInputRef", "gpuLayersInputRef", "moeLayersInputRef"):
+ assert f"const {ref} = useRef(null);" in page
+ assert f"{ref}.current?.commit()" in page
+ assert f"inputRef={{{ref}}}" in page
+ # The leaf sub-components accept and forward the handle as a ref.
+ assert page.count("inputRef?: Ref;") >= 2
+ assert "ref={inputRef}" in page
+ # Committed drafts are folded into the staged config, gated on non-null so an
+ # untouched field never fabricates an override.
+ assert "committedMaxSeqLength != null" in page
+ assert "committedGpuLayers != null" in page
+ assert "committedMoeLayers != null" in page
+ assert "pendingPatch.gpuLayers = committedGpuLayers;" in page
+ assert "pendingPatch.nCpuMoe = committedMoeLayers;" in page
+ # The non-GGUF load path substitutes the committed Max Seq Length draft.
+ assert "const effectiveMaxSeqLengthValue =" in page
+ assert "maxSeqLength: effectiveMaxSeqLengthValue" in page
+
+
+def test_context_commit_rechecks_persistence_only_shortcut():
+ """Committed context changes must bypass persistence-only saves."""
+ src = _read("features/model-picker/components/model-config-page.tsx")
+ assert "const effectiveConfig =" in src
+ assert "perModelConfigsEqual(effectiveConfig, baseline)" in src
+ assert "const effectivePersistenceOnly =" in src
+ assert "if (effectivePersistenceOnly)" in src
+
+
def test_reset_enabled_for_explicit_context_pin_at_native():
"""An explicit customContextLength that equals the native ceiling is still a
user override, so contextAtDefault must require customContextLength == null.
{activeView === "easy" ? (
From 478d30f361a05f25a4e386c04175011eebcb507c Mon Sep 17 00:00:00 2001
From: Leo Borcherding
Date: Fri, 24 Jul 2026 22:23:41 -0500
Subject: [PATCH 4/6] Unsloth Studio (desktop): fix canvas preview, download
file button, toast placement, and model-load typing lag (#7391)
* Studio desktop: fix loading-toast overlap and typing lag on model load
- Toaster: on desktop, offset toasts below the ~34px custom window titlebar
(top 46 when isTauri) so they no longer cover the min/max/close controls.
Web is unchanged (top 12).
- Model load: the 2s load poll wrote loadProgress state every tick, which
re-renders the whole chat page during "Starting model" (cheap in Chrome,
janky in the desktop WebView2 -> laggy typing). That state is only read by
the dismissed-toast inline status, so gate all four poll branches to write
it only when the inline view is live; while the toast is up it updates via
Sonner alone.
* Studio desktop: fix HTML canvas preview, download, and panel offset
- CSP: add frame-src for localhost/127.0.0.1 so the desktop webview can
frame the backend-served artifact preview. default-src 'self' (no
frame-src) blocked it -> "127.0.0.1 refused to connect"; web is
same-origin so it already worked.
- Download: route the canvas Download button through the native save
dialog (downloadFile) instead of a blob-anchor click, which the Tauri
WebView2 silently drops.
- Nudge the artifact panel down 8px so its top edge/shadow isn't tucked
under the window top bar.
* Studio desktop: add HTML filter for native canvas save dialog
Canvas Download saves .html via save_native_file, but save_filter() had no
html/htm case, so the native dialog fell back to the JSON/CSV/etc filter and
could block saving/browsing the .html export. Add an HTML filter and include
html/htm in the catch-all. Addresses Codex review on #7391.
* Studio desktop: unblock canvas preview in dev shell + clear header fade
- Preview: the app CSP frame-src fix wasn't enough in the tauri dev shell.
The preview endpoint sets its own frame-ancestors response header, which
only allowed 'self' tauri://localhost http://tauri.localhost -- so the
Vite dev origin (http://localhost:5173) was blocked and the frame stayed
"refused to connect". Extend the allowlist with http://localhost:* and
http://127.0.0.1:* (the endpoint only renders postMessage'd HTML in a
no-same-origin sandbox, so it exposes no server resource).
- Shadow: the artifact panel toolbar sat under the full-width
chat-header-fade; lower the panel top (mt 80->90px) so the controls clear
the fade.
* [pre-commit.ci] auto fixes from pre-commit.com hooks
for more information, see https://pre-commit.ci
---------
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
---
studio/backend/routes/inference.py | 11 +++-
studio/frontend/src/app/provider.tsx | 6 +-
.../chat/artifacts/artifact-surface.tsx | 30 ++++-----
.../chat/hooks/use-chat-model-runtime.ts | 62 ++++++++++++-------
studio/src-tauri/src/native_file_dialogs.rs | 11 +++-
studio/src-tauri/tauri.conf.json | 2 +-
6 files changed, 80 insertions(+), 42 deletions(-)
diff --git a/studio/backend/routes/inference.py b/studio/backend/routes/inference.py
index 4e74e1d32d..9d40650a56 100644
--- a/studio/backend/routes/inference.py
+++ b/studio/backend/routes/inference.py
@@ -1794,7 +1794,16 @@ router = APIRouter()
studio_router = APIRouter()
-_ARTIFACT_PREVIEW_FRAME_ANCESTORS = "'self' tauri://localhost http://tauri.localhost"
+# Packaged desktop runs at tauri://localhost (macOS/Linux) or http://tauri.localhost
+# (Windows WebView2); the web build is same-origin ('self'). The `tauri dev` shell,
+# however, serves the frontend from the Vite dev origin (http://localhost:5173),
+# so the packaged allowlist alone leaves the preview blocked in dev with an
+# "ancestor violates frame-ancestors" error. This shell exposes no server resource
+# (it only renders postMessage'd HTML in a no-same-origin sandbox), so also allowing
+# any localhost/127.0.0.1 dev origin to frame it is safe and unblocks the dev shell.
+_ARTIFACT_PREVIEW_FRAME_ANCESTORS = (
+ "'self' tauri://localhost http://tauri.localhost http://localhost:* http://127.0.0.1:*"
+)
_ARTIFACT_PREVIEW_FRAME_STRICT_CSP = (
"default-src 'none'; "
"script-src 'unsafe-inline'; "
diff --git a/studio/frontend/src/app/provider.tsx b/studio/frontend/src/app/provider.tsx
index e6c89b9cd7..9232defd70 100644
--- a/studio/frontend/src/app/provider.tsx
+++ b/studio/frontend/src/app/provider.tsx
@@ -524,8 +524,10 @@ export function AppProvider({ children }: AppProviderProps) {
visibleToasts={2}
expand={true}
closeButton={true}
- // Clear the chat header buttons on the right.
- offset={{ top: 12, right: 64 }}
+ // Clear the chat header buttons on the right. On desktop, also drop
+ // below the ~34px custom window titlebar so toasts don't cover the
+ // minimize / maximize / close controls.
+ offset={{ top: isTauri ? 46 : 12, right: 64 }}
/>
diff --git a/studio/frontend/src/features/chat/artifacts/artifact-surface.tsx b/studio/frontend/src/features/chat/artifacts/artifact-surface.tsx
index 0f4c83e0db..1955c3aca1 100644
--- a/studio/frontend/src/features/chat/artifacts/artifact-surface.tsx
+++ b/studio/frontend/src/features/chat/artifacts/artifact-surface.tsx
@@ -12,6 +12,8 @@ import {
import { MascotImg } from "@/components/mascot-img";
import { Button } from "@/components/ui/button";
import { copyToClipboard } from "@/lib/copy-to-clipboard";
+import { downloadFile, isDownloadCancelled } from "@/lib/native-files";
+import { toast } from "@/lib/toast";
import { cn } from "@/lib/utils";
import { CopyIcon, EyeIcon, Maximize2Icon, XIcon } from "lucide-react";
import { Download01Icon } from "@hugeicons/core-free-icons";
@@ -91,18 +93,6 @@ function ArtifactGeneratingPanel() {
);
}
-function downloadTextFile(filename: string, text: string): void {
- const blob = new Blob([text], { type: "text/html;charset=utf-8" });
- const url = URL.createObjectURL(blob);
- const anchor = document.createElement("a");
- anchor.href = url;
- anchor.download = filename;
- document.body.appendChild(anchor);
- anchor.click();
- document.body.removeChild(anchor);
- window.setTimeout(() => URL.revokeObjectURL(url), 0);
-}
-
export function ArtifactSurface({
artifact,
variant,
@@ -205,7 +195,7 @@ export function ArtifactSurface({
className={cn(
"relative flex min-h-0 flex-col bg-background",
variant === "panel"
- ? "artifact-panel-shell mx-2 mt-[72px] mb-8 h-[calc(100%_-_104px)] overflow-visible rounded-[28px] border-t border-border/70 bg-card/95"
+ ? "artifact-panel-shell mx-2 mt-[90px] mb-8 h-[calc(100%_-_122px)] overflow-visible rounded-[28px] border-t border-border/70 bg-card/95"
: "h-[min(92vh,900px)] w-[min(96vw,1200px)] overflow-hidden rounded-2xl border border-border shadow-xl",
)}
aria-label={`${artifact.title} canvas`}
@@ -265,7 +255,19 @@ export function ArtifactSurface({
size="icon"
className="size-8"
disabled={isLoadingArtifact || !hasArtifactCode}
- onClick={() => downloadTextFile(filename, artifact.code)}
+ onClick={() => {
+ // Route through the native save dialog on desktop; the plain
+ // blob-anchor download is silently dropped by the Tauri WebView2.
+ void downloadFile(
+ artifact.code,
+ filename,
+ "text/html;charset=utf-8",
+ ).catch((err) => {
+ if (!isDownloadCancelled(err)) {
+ toast.error("Failed to save canvas HTML");
+ }
+ });
+ }}
aria-label="Download canvas HTML"
>
Date: Fri, 24 Jul 2026 22:34:48 -0700
Subject: [PATCH 5/6] tests: restore the inheritance-before-guard ordering
assertion (#7251)
The gguf order fix that landed on main dropped the only assertion
covering the prerequisite that llama_extra_args inheritance runs before
the GGUF branch: the inherited value (a carried --no-mmproj) shapes the
hub guard's require_mmproj, so a future reorder could reject a load
over an mmproj download the inherited arguments would disable. The
comment also misattributed the inheritance site to
_guard_chat_load_against_training.
The assertion is restored anchored on the call form
"= _resolve_inherited_extra_args(", which pins the endpoint's call site
(the bare name would match the function definition, which always
precedes the endpoint, making the check vacuous), and the comment now
names the real inheritance site. 32 tests pass.
---
studio/backend/tests/test_gguf_load_cache_reuse.py | 9 ++++++---
1 file changed, 6 insertions(+), 3 deletions(-)
diff --git a/studio/backend/tests/test_gguf_load_cache_reuse.py b/studio/backend/tests/test_gguf_load_cache_reuse.py
index 6d1fac980b..dfd6fc6034 100644
--- a/studio/backend/tests/test_gguf_load_cache_reuse.py
+++ b/studio/backend/tests/test_gguf_load_cache_reuse.py
@@ -789,9 +789,12 @@ class TestLoadHubDownloadExclusion:
# The gguf_load_in_flight marker must be entered before the hub-download
# guard and the unload so a concurrent load can't race the download
- # manager. The llama_extra_args inheritance that used to sit between the
- # marker and the guard now runs in _guard_chat_load_against_training, ahead
- # of the GGUF branch, so it is no longer a landmark inside this slice.
+ # manager. The llama_extra_args inheritance moved out of the branch into
+ # _resolve_inherited_extra_args, which must still run BEFORE it: the
+ # inherited value (e.g. a carried --no-mmproj) shapes the guard's
+ # require_mmproj. Anchor on the call form so the assertion pins the
+ # endpoint's call site, not the function definition.
+ assert source.index("= _resolve_inherited_extra_args(") < source.index("if config.is_gguf:")
assert (
gguf_branch.index("enter_context(gguf_load_in_flight")
< gguf_branch.index("_hub_download_blocks_gguf_load")
From dffea2af27b9ee5a10479fb6566184394d6921cd Mon Sep 17 00:00:00 2001
From: Souravrajvi0 <144546710+Souravrajvi0@users.noreply.github.com>
Date: Sat, 25 Jul 2026 11:57:47 +0530
Subject: [PATCH 6/6] fix(studio): honor run settings on initial model load
(#7346) (#7351)
* fix(studio): honor run settings on initial model load
When loading a model from the gear-icon run-settings page, Context Length
and KV Cache Dtype were ignored if the user clicked Load before blurring
the context field, or before React flushed staged config into the store.
- Add NumericValueInput.commit() to flush a focused draft on Load
- Pass effectiveLoadConfig from model-config-page to onRun
- Prefer selection.config in performLoad for all load knobs
- Preserve meta.forceReload from the config-page reload path
Fixes #7346
* fix(studio): flush NumericValueInput draft when Load blurs first
Clicking Load blurs the context field before handleRun runs, so commit()
returned the stale value prop. Keep draft in a ref and parse it even when
the input is no longer focused.
* fix(studio): preserve Auto context when Load is clicked without edits
NumericValueInput.commit() now returns null unless the user actually
changed the field, so GGUF Load/Save no longer pins the displayed native
context into customContextLength when Auto was left untouched.
* fix(studio): clear NumericValueInput dirty state after blur commit
After a normal blur commit, reset dirtyRef so a later Load cannot replay a
stale draftRef when the user changed context via Reset or the slider.
* test(studio): pin NumericValueInput Auto/dirty contracts for #7346
Lock Codex P1/P2: commit returns null unless dirty, blur clears dirtyRef,
and handleRun only promotes a non-null committed context.
* fix(studio): keep same-click context draft after blur (#7346)
Blur can commit and clear dirtyRef before Load's onClick; stash that
committed value for one imperative commit() so typed context is not lost.
* chore: refresh PR head for #7351
* fix(studio): handle context commit edge cases
* chore: refresh PR head
* test(studio): guard invalid context drafts
* style(studio): format context draft guard
* test(studio): exercise same-click model config loads
* fix(studio): drop stale blur pin when the typed context equals the shown value
NumericValueInput cached every blur commit in lastBlurCommittedRef, even when
the draft equalled the current value and no onChange was dispatched. Because the
displayed value never changed, the useEffect([value]) clear never fired, so a
later Reset or external edit that leaves the shown value unchanged could not drop
the cache and the next commit() replayed it into an override that Reset had
removed. Only cache the blur result when it actually dispatched onChange
(final !== value); when final === value the parent is already current and there
is nothing to bridge. Add a Playwright regression that re-types the shown context
and asserts no override is stored.
* [pre-commit.ci] auto fixes from pre-commit.com hooks
for more information, see https://pre-commit.ci
* Studio: commit every same-click numeric draft before staging the load config
The run-settings Load/Reload button flushed only the GGUF Context Length draft
imperatively before building the load config. Max Seq Length (non-GGUF), GPU
Layers and MoE Layers on CPU (GGUF) are the same NumericValueInput and stage
their typed value only on blur, so editing one and clicking Load in the same
gesture staged the load from a still-stale parent config and dropped the value
the user just typed.
Wire an imperative commit handle through those inputs too and fold every
committed draft into the effective config, recomputing the non-GGUF load-time
max sequence length from the committed draft.
* fix(studio): recompute fixed-layer context pin and drop stale blur cache on every render
Two run-settings edge cases on the model-config page:
1) pinFixedLayerContext was computed from the render-time config, before a
same-click GPU Layers draft is committed in handleRun. Typing a positive
fixed-layer value on an auto-fit GGUF and clicking Reload therefore built
the runtime config with customContextLength: null, so a later fresh load
sent the native context with fixed layers (the OOM the pin exists to
avoid). Recompute the pin from the committed effectiveConfig.
2) NumericValueInput cleared its blur bridge only on a value change. A real
edit (final !== value) that Reset then reverts to the same shown number
nets value back unchanged, so the effect never re-ran and the stale pin
survived into the next Load/Save, replaying the override Reset removed.
The bridge is only valid across the single synchronous same-click gesture
that set it, so clear it on every settled render instead.
Add source-contract regressions for both.
* [pre-commit.ci] auto fixes from pre-commit.com hooks
for more information, see https://pre-commit.ci
---------
Co-authored-by: Unsloth
Co-authored-by: Michael Han <107991372+shimmyshimmer@users.noreply.github.com>
Co-authored-by: Daniel Han
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
---
.../frontend/src/features/chat/chat-page.tsx | 2 +-
.../chat/hooks/use-chat-model-runtime.ts | 78 +++++---
.../components/model-config-page.tsx | 128 ++++++++++++--
.../components/numeric-value-input.tsx | 166 ++++++++++++++----
.../src/features/model-picker/index.ts | 1 +
tests/studio/playwright_model_config.py | 69 +++++++-
tests/studio/test_model_picker_contracts.py | 117 +++++++++++-
7 files changed, 479 insertions(+), 82 deletions(-)
diff --git a/studio/frontend/src/features/chat/chat-page.tsx b/studio/frontend/src/features/chat/chat-page.tsx
index 7452cf3447..a439a91239 100644
--- a/studio/frontend/src/features/chat/chat-page.tsx
+++ b/studio/frontend/src/features/chat/chat-page.tsx
@@ -2676,7 +2676,7 @@ export function ChatPage({
config: meta?.config,
nativePathToken: meta?.nativePathToken,
nativePathExpiresAtMs: meta?.nativePathExpiresAtMs,
- forceReload: isSameLoadedModel || undefined,
+ forceReload: meta?.forceReload ?? (isSameLoadedModel || undefined),
};
await stageOrLoad(selection);
})();
diff --git a/studio/frontend/src/features/chat/hooks/use-chat-model-runtime.ts b/studio/frontend/src/features/chat/hooks/use-chat-model-runtime.ts
index bb19223a6a..48a6168555 100644
--- a/studio/frontend/src/features/chat/hooks/use-chat-model-runtime.ts
+++ b/studio/frontend/src/features/chat/hooks/use-chat-model-runtime.ts
@@ -62,6 +62,7 @@ import {
import { isExternalModelId } from "../external-providers";
import {
applyPerModelConfigToRuntime,
+ normalizeMaxSeqLength,
type PerModelConfig,
} from "@/features/model-picker";
import type {
@@ -604,12 +605,19 @@ export function useChatModelRuntime() {
async function performLoad(): Promise {
if (abortCtrl.signal.aborted) throw new Error("Cancelled");
let previousWasUnloaded = false;
+ const pendingLoadConfig =
+ typeof selection !== "string" ? selection.config : undefined;
+ if (pendingLoadConfig) {
+ applyPerModelConfigToRuntime(pendingLoadConfig);
+ }
const currentCheckpoint =
useChatRuntimeStore.getState().params.checkpoint;
const stateBeforeUnload = useChatRuntimeStore.getState();
let trustRemoteCode = stateBeforeUnload.params.trustRemoteCode ?? false;
let approvedRemoteCodeFingerprint: string | null = null;
- const maxSeqLength = stateBeforeUnload.params.maxSeqLength;
+ const maxSeqLength =
+ normalizeMaxSeqLength(pendingLoadConfig?.maxSeqLength) ??
+ stateBeforeUnload.params.maxSeqLength;
const previousActiveNativePathToken =
stateBeforeUnload.activeNativePathToken;
const previousIsGguf =
@@ -643,34 +651,54 @@ export function useChatModelRuntime() {
const previousActiveNativePathExpiresAtMs =
stateBeforeUnload.activeNativePathExpiresAtMs;
// Snapshot the load settings at click time, before the awaits below
- // (validation, the trust dialog, unload).
- const loadChatTemplateOverride = stateBeforeUnload.chatTemplateOverride;
- const loadKvCacheDtype = stateBeforeUnload.kvCacheDtype;
+ // (validation, the trust dialog, unload). When the picker staged a
+ // config payload, prefer it over the store: React may not have
+ // flushed NumericValueInput's blur commit into state yet.
+ const loadChatTemplateOverride =
+ pendingLoadConfig?.chatTemplateOverride?.trim()
+ ? pendingLoadConfig.chatTemplateOverride
+ : stateBeforeUnload.chatTemplateOverride;
+ const loadKvCacheDtype =
+ pendingLoadConfig?.kvCacheDtype ?? stateBeforeUnload.kvCacheDtype;
// gpuMemoryMode is a standing preference (kept across a model switch);
// the rest are per-model knobs the reset below clears, so they are
// re-baselined there in lock-step with the store.
- let loadCustomContextLength = stateBeforeUnload.customContextLength;
+ let loadCustomContextLength =
+ pendingLoadConfig?.customContextLength ??
+ stateBeforeUnload.customContextLength;
const loadGgufContextLength = stateBeforeUnload.ggufContextLength;
- const loadTensorParallel = stateBeforeUnload.tensorParallel;
+ const loadTensorParallel =
+ pendingLoadConfig?.tensorParallel ?? stateBeforeUnload.tensorParallel;
const loadActivePresetSource = stateBeforeUnload.activePresetSource;
const loadActiveGgufVariant = stateBeforeUnload.activeGgufVariant;
- const loadGpuMemoryMode = stateBeforeUnload.gpuMemoryMode;
- let loadGpuLayers = stateBeforeUnload.gpuLayers;
- let loadNCpuMoe = stateBeforeUnload.nCpuMoe;
+ const loadGpuMemoryMode =
+ pendingLoadConfig?.gpuMemoryMode ?? stateBeforeUnload.gpuMemoryMode;
+ let loadGpuLayers =
+ pendingLoadConfig?.gpuLayers ?? stateBeforeUnload.gpuLayers;
+ let loadNCpuMoe =
+ pendingLoadConfig?.nCpuMoe ?? stateBeforeUnload.nCpuMoe;
let loadSplitRatio = stateBeforeUnload.splitRatio;
// Reconcile the persisted pick against the GPUs present now, so a stale
// cross-host / now-hidden pick is dropped before /load rather than
// rejected there. Warm the device cache first: load-on-selection can
// run before any GPU hook mounted, and a cold cache would pass the
// pick through unvalidated. validateGpuIds derives from this too.
- if (stateBeforeUnload.selectedGpuIds != null) {
+ if (
+ pendingLoadConfig?.selectedGpuIds !== undefined ||
+ stateBeforeUnload.selectedGpuIds != null
+ ) {
await ensureGpuDeviceCache();
}
- let loadSelectedGpuIds = reconcilePersistedGpuIds(
- stateBeforeUnload.selectedGpuIds,
- );
- let loadSpeculativeType = stateBeforeUnload.speculativeType;
- let loadSpecDraftNMax = stateBeforeUnload.specDraftNMax;
+ let loadSelectedGpuIds =
+ pendingLoadConfig?.selectedGpuIds !== undefined
+ ? reconcilePersistedGpuIds(pendingLoadConfig.selectedGpuIds)
+ : reconcilePersistedGpuIds(stateBeforeUnload.selectedGpuIds);
+ let loadSpeculativeType =
+ pendingLoadConfig?.speculativeType != null
+ ? normalizeSpeculativeType(pendingLoadConfig.speculativeType)
+ : stateBeforeUnload.speculativeType;
+ let loadSpecDraftNMax =
+ pendingLoadConfig?.specDraftNMax ?? stateBeforeUnload.specDraftNMax;
try {
// Lightweight pre-flight validation: avoid unloading a working model
// if the new identifier is clearly invalid (e.g. bad HF id / path).
@@ -810,15 +838,23 @@ export function useChatModelRuntime() {
// model loads at Auto/native, not the previous model's pin.
customContextLength: null,
});
- loadSpeculativeType = persistedSpeculativeType;
- loadSpecDraftNMax = null;
+ loadSpeculativeType =
+ pendingLoadConfig?.speculativeType != null
+ ? normalizeSpeculativeType(pendingLoadConfig.speculativeType)
+ : persistedSpeculativeType;
+ loadSpecDraftNMax = pendingLoadConfig?.specDraftNMax ?? null;
// Keep the click-time snapshot in lock-step with the store reset so
// the load below sizes against the cleared per-model knobs, not the
// previous model's (gpuMemoryMode is standing, so left as captured).
- loadCustomContextLength = null;
- loadSelectedGpuIds = null;
- loadGpuLayers = GPU_LAYERS_AUTO;
- loadNCpuMoe = 0;
+ // An explicit staged config from run-settings still wins.
+ loadCustomContextLength =
+ pendingLoadConfig?.customContextLength ?? null;
+ loadSelectedGpuIds =
+ pendingLoadConfig?.selectedGpuIds !== undefined
+ ? reconcilePersistedGpuIds(pendingLoadConfig.selectedGpuIds)
+ : null;
+ loadGpuLayers = pendingLoadConfig?.gpuLayers ?? GPU_LAYERS_AUTO;
+ loadNCpuMoe = pendingLoadConfig?.nCpuMoe ?? 0;
loadSplitRatio = null;
}
diff --git a/studio/frontend/src/features/model-picker/components/model-config-page.tsx b/studio/frontend/src/features/model-picker/components/model-config-page.tsx
index afbd33af7c..90202a2bcf 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
@@ -24,7 +24,14 @@ import { ChevronDownStandardIcon } from "@/lib/chevron-icons";
import { toast } from "@/lib/toast";
import { ArrowLeft01Icon } from "@hugeicons/core-free-icons";
import { HugeiconsIcon } from "@hugeicons/react";
-import { type ReactNode, useEffect, useId, useState } from "react";
+import {
+ type ReactNode,
+ type Ref,
+ useEffect,
+ useId,
+ useRef,
+ useState,
+} from "react";
import {
useDefaultChatTemplate,
useModelMaxPositionEmbeddings,
@@ -50,7 +57,10 @@ import {
} from "../model-config/per-model-config";
import { ChatTemplateEditorDialog } from "./chat-template-editor-dialog";
import type { ModelPickTarget } from "./model-selector/types";
-import { NumericValueInput } from "./numeric-value-input";
+import {
+ NumericValueInput,
+ type NumericValueInputHandle,
+} from "./numeric-value-input";
const ROW_CLASS = "flex min-h-8 items-center justify-between gap-3";
const LABEL_CLASS =
@@ -130,11 +140,13 @@ function MaxSeqLengthSetting({
max,
inputMax,
onChange,
+ inputRef,
}: {
value: number;
max: number;
inputMax: number;
onChange: (value: number) => void;
+ inputRef?: Ref;
}) {
return (
void;
displayValue?: string;
info?: ReactNode;
+ inputRef?: Ref;
}) {
return (
) => void;
layerCount: number | null;
moeLayerCount: number | null;
+ gpuLayersInputRef?: Ref;
+ moeLayersInputRef?: Ref;
}) {
const gpuDevices = useGpuDevices();
const mode = config.gpuMemoryMode ?? "auto";
@@ -322,6 +342,7 @@ function GpuMemorySettings({
<>
) => void;
@@ -407,6 +431,8 @@ function GgufAdvancedSettings({
onEditTemplate: () => void;
layerCount: number | null;
moeLayerCount: number | null;
+ gpuLayersInputRef?: Ref;
+ moeLayersInputRef?: Ref;
}) {
return (
<>
@@ -535,6 +561,8 @@ function GgufAdvancedSettings({
update={update}
layerCount={layerCount}
moeLayerCount={moeLayerCount}
+ gpuLayersInputRef={gpuLayersInputRef}
+ moeLayersInputRef={moeLayersInputRef}
/>
(null);
+ const maxSeqLengthInputRef = useRef(null);
+ const gpuLayersInputRef = useRef(null);
+ const moeLayersInputRef = useRef(null);
const nativePathToken =
target.meta.nativePathToken ??
(isActiveModel ? activeNativePathToken : null);
@@ -744,11 +776,6 @@ export function ModelConfigPage({
? { ...config, customContextLength: activeLoadedContext }
: config
: config;
- // Load request needs a concrete max length; substitute the fallback here only,
- // never in the persisted runtimeConfig.
- const loadConfig = target.isGguf
- ? runtimeConfig
- : { ...runtimeConfig, maxSeqLength: maxSeqLengthValue };
const rememberChanged = remember !== savedRemember;
const persistenceOnly = isActiveModel && atBaseline && rememberChanged;
const primaryActionLabel = persistenceOnly
@@ -760,18 +787,90 @@ export function ModelConfigPage({
: "Load model";
const handleRun = () => {
- const defaultConfig = isDefaultConfig(runtimeConfig);
+ // Same-click Load/Reload: a numeric draft the user just typed is flushed only
+ // by that input's blur handler, which updates the parent config after this
+ // click closure already captured the stale value. Commit every numeric input
+ // imperatively so the staged load honors what the user just typed, not just
+ // the Context field.
+ const committedContext = target.isGguf
+ ? contextInputRef.current?.commit()
+ : undefined;
+ const committedMaxSeqLength = target.isGguf
+ ? undefined
+ : maxSeqLengthInputRef.current?.commit();
+ const committedGpuLayers = target.isGguf
+ ? gpuLayersInputRef.current?.commit()
+ : undefined;
+ const committedMoeLayers = target.isGguf
+ ? moeLayersInputRef.current?.commit()
+ : undefined;
+
+ const pendingPatch: Partial = {};
+ if (committedContext != null) {
+ pendingPatch.customContextLength = committedContext;
+ }
+ if (committedMaxSeqLength != null) {
+ pendingPatch.maxSeqLength = clampMaxSeqLength(
+ committedMaxSeqLength,
+ MAX_SEQ_LENGTH_MAX,
+ );
+ }
+ if (committedGpuLayers != null) {
+ pendingPatch.gpuLayers = committedGpuLayers;
+ }
+ if (committedMoeLayers != null) {
+ pendingPatch.nCpuMoe = committedMoeLayers;
+ }
+ const hasPending =
+ committedContext != null ||
+ committedMaxSeqLength != null ||
+ committedGpuLayers != null ||
+ committedMoeLayers != null;
+
+ const effectiveConfig = hasPending
+ ? { ...config, ...pendingPatch }
+ : config;
+ // pinFixedLayerContext above was computed from the render-time config, before
+ // the same-click GPU Layers draft was committed. Recompute it from
+ // effectiveConfig so committing a positive fixed-layer value still pins the
+ // fitted context; otherwise the saved config carries customContextLength: null
+ // and a later fresh load sends the native context with fixed layers (the OOM
+ // the pin exists to avoid).
+ const effectivePinFixedLayerContext =
+ target.isGguf &&
+ effectiveConfig.gpuMemoryMode === "manual" &&
+ effectiveConfig.gpuLayers != null &&
+ effectiveConfig.gpuLayers >= 0 &&
+ effectiveConfig.customContextLength == null &&
+ activeLoadedContext != null;
+ const effectiveRuntimeConfig = hasPending
+ ? effectivePinFixedLayerContext
+ ? { ...effectiveConfig, customContextLength: activeLoadedContext }
+ : effectiveConfig
+ : runtimeConfig;
+ // Non-GGUF load substitutes the resolved max sequence length; recompute it
+ // from the committed draft so a same-click Max Seq Length edit is not lost.
+ const effectiveMaxSeqLengthValue =
+ committedMaxSeqLength == null
+ ? maxSeqLengthValue
+ : (normalizeMaxSeqLength(effectiveConfig.maxSeqLength) ??
+ clampMaxSeqLength(DEFAULT_MAX_SEQ_LENGTH, nativeMaxSeqLength));
+ // Recheck the committed draft so Save/Forget reloads when needed.
+ const effectiveAtBaseline = perModelConfigsEqual(effectiveConfig, baseline);
+ const effectivePersistenceOnly =
+ isActiveModel && effectiveAtBaseline && rememberChanged;
+ const defaultConfig = isDefaultConfig(effectiveRuntimeConfig);
let saveFailed = false;
if (remember) {
saveFailed = !savePerModelConfig(
target.id,
target.ggufVariant,
- runtimeConfig,
+ effectiveRuntimeConfig,
);
} else {
saveFailed = !deletePerModelConfig(target.id, target.ggufVariant);
}
- if (persistenceOnly) {
+ if (effectivePersistenceOnly) {
if (saveFailed) {
toast.error("Couldn't save settings for this model.");
return;
@@ -791,7 +890,10 @@ export function ModelConfigPage({
if (saveFailed) {
toast.error("Couldn't save these settings, loading with them anyway.");
}
- onRun(loadConfig);
+ const effectiveLoadConfig = target.isGguf
+ ? effectiveRuntimeConfig
+ : { ...effectiveRuntimeConfig, maxSeqLength: effectiveMaxSeqLengthValue };
+ onRun(effectiveLoadConfig);
};
return (
@@ -838,6 +940,7 @@ export function ModelConfigPage({
@@ -146,6 +158,7 @@ function MaxSeqLengthSetting({
@@ -199,6 +214,7 @@ function AdvancedGpuSlider({
{info && {info} }