Skip to content

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

Studio: do not roll back a model switch whose load got no answer (#11729)

Daniel Hancc33d51ebf5c
diff --git a/studio/frontend/src/features/chat/api/padded-response.ts b/studio/frontend/src/features/chat/api/padded-response.ts
index 0d0d88f593c..4f77e18a71a 100644
--- a/studio/frontend/src/features/chat/api/padded-response.ts
+++ b/studio/frontend/src/features/chat/api/padded-response.ts
@@ -15,7 +15,11 @@ export function assertCompletedPaddedBody(body: unknown, label: string): void {
if (complete) {
return;
}
- throw new Error(
- `${label} did not report completion: the connection closed before the server's reply arrived. Check the model's status before retrying.`,
+ // Tagged like a failed fetch: the connection closed, so the backend's outcome is unknown.
+ throw Object.assign(
+ new Error(
+ `${label} did not report completion: the connection closed before the server's reply arrived. Check the model's status before retrying.`,
+ ),
+ { unslothTransportFailure: true },
);
}
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 bbb399b8fab..ca839ab2a5b 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
@@ -7,6 +7,7 @@ import {
watchCacheMissDownload,
} from "../lib/cache-miss-download";
import { mlxRuntimeStateFrom } from "../lib/mlx-runtime-state";
+import { shouldRestorePreviousModel } from "../lib/restore-previous-model";
import {
type ServerTuningValues,
clearedServerTuningState,
@@ -2182,7 +2183,13 @@ export function useChatModelRuntime() {
notifyLocalPromptQueueLoadFailed(lifecycleLease);
// Cancellation already handles unloading.
if (abortCtrl.signal.aborted) throw error;
- if (previousWasUnloaded && previousCheckpoint) {
+ // A load that got no answer may still be running (a page reload mid-load, for one): putting the
+ // previous model back would replace it. Only an answered failure is safe to roll back.
+ if (
+ previousWasUnloaded &&
+ previousCheckpoint &&
+ shouldRestorePreviousModel(error)
+ ) {
let rollbackNativePathLease: string | undefined;
if (previousActiveNativePathToken) {
try {
diff --git a/studio/frontend/src/features/chat/lib/restore-previous-model.ts b/studio/frontend/src/features/chat/lib/restore-previous-model.ts
new file mode 100644
index 00000000000..2af714689c1
--- /dev/null
+++ b/studio/frontend/src/features/chat/lib/restore-previous-model.ts
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+// Whether a model switch that failed after unloading the previous model may load that model back.
+
+/**
+ * A load that never got an answer did not fail on the backend: the connection closed first.
+ * `/api/inference/load` keeps running when its client goes away (see `_tunnel_safe_json` in
+ * routes/inference.py), so the model that was asked for is still loading or already resident.
+ * Loading the previous model back from here races it and usually wins, since the rollback is
+ * sent with `force_cancel_active` and queues right behind it.
+ *
+ * The common way to get here is reloading the page while a load is in flight: both Chromium and
+ * Firefox reject the old document's pending fetch and still let its catch send a request. The
+ * rollback then replaced the model the user had just loaded with the one it replaced, at that
+ * model's old context, and the reloaded page read the remembered Context Length as no longer
+ * applying to what was running.
+ *
+ * `unslothTransportFailure` is set by `authFetch` when fetch itself rejects, and by
+ * `assertCompletedPaddedBody` when a padded reply is cut off. An HTTP error or a deferred error in
+ * the body is an answer, and keeps the rollback.
+ */
+export function loadOutcomeUnknown(error: unknown): boolean {
+ return (
+ typeof error === "object" &&
+ error !== null &&
+ (error as { unslothTransportFailure?: unknown }).unslothTransportFailure ===
+ true
+ );
+}
+
+/** True when the backend reported the failure, so restoring the unloaded model cannot undo a load. */
+export function shouldRestorePreviousModel(error: unknown): boolean {
+ return !loadOutcomeUnknown(error);
+}
diff --git a/studio/frontend/tests/load-rollback-after-lost-reply.test.ts b/studio/frontend/tests/load-rollback-after-lost-reply.test.ts
new file mode 100644
index 00000000000..e914fcd5cf8
--- /dev/null
+++ b/studio/frontend/tests/load-rollback-after-lost-reply.test.ts
@@ -0,0 +1,213 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+// A model switch whose /api/inference/load got no answer must not load the previous model back.
+//
+// Switching (or reloading the same model with new settings) unloads the resident model first, and a
+// failed load then restores it. That is right when the backend REPORTED the failure. It is wrong when
+// the connection closed before any answer, because the backend keeps loading after its client goes
+// away: the rollback, sent with force_cancel_active, queued behind the load and replaced it.
+//
+// Reloading the page mid-load is the everyday way to get there. Chromium and Firefox both reject the
+// old document's pending fetch and still let its catch send one more request. Seen in the Chat UI
+// extra lane (playwright_model_config.py, "context length 4096 persists"): the 4096 load finished,
+// the dying page's rollback then loaded the model back at its previous 2048, and the reloaded page
+// correctly declined to show the remembered 4096 for a server running 2048, so it read "Auto".
+//
+// The rollback lives inside performLoad with no seam to call, so the guard is checked at the source,
+// and everything that feeds it (authFetch, loadModel, the padded-body check) runs for real against a
+// loopback server that drops the connection the way a page reload does.
+
+import assert from "node:assert/strict";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import test from "node:test";
+
+import { readSrc } from "./helpers/kit.ts";
+import { loadWithStubs } from "./helpers/module-stubs.ts";
+
+const paddedResponse = await import("../src/features/chat/api/padded-response.ts");
+const { shouldRestorePreviousModel, loadOutcomeUnknown } = await import(
+ "../src/features/chat/lib/restore-previous-model.ts"
+);
+
+const RUNTIME = readSrc("features/chat/hooks/use-chat-model-runtime.ts");
+
+type Reply = "drop" | "padded-drop" | "rejected" | "deferred" | "loaded";
+
+type AuthApi = {
+ authFetch: (input: string, init?: RequestInit) => Promise<Response>;
+};
+type ChatApi = {
+ loadModel: (payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
+};
+
+async function withLoadServer(
+ reply: Reply,
+ run: (port: number) => Promise<void>,
+): Promise<void> {
+ const server: Server = createServer((req: IncomingMessage, res: ServerResponse) => {
+ req.resume();
+ req.on("end", () => {
+ if (reply === "drop") {
+ // The request arrived and the reply never will: what the old page sees on reload.
+ req.socket.destroy();
+ return;
+ }
+ if (reply === "padded-drop") {
+ // A load past _TUNNEL_KEEPALIVE_AFTER_S has committed its 200 and is padding when the page goes.
+ res.writeHead(200, { "Content-Type": "application/json" });
+ res.write(" ");
+ setTimeout(() => req.socket.destroy(), 20);
+ return;
+ }
+ const body =
+ reply === "rejected"
+ ? { detail: "Not enough memory to load this model." }
+ : reply === "deferred"
+ ? { _deferred_error: { status_code: 500, detail: "llama-server exited" } }
+ : { status: "loaded", model: "unsloth/gemma-3-270m-it-GGUF" };
+ res.writeHead(reply === "rejected" ? 500 : 200, {
+ "Content-Type": "application/json",
+ });
+ res.end(JSON.stringify(body));
+ });
+ });
+ await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+ const address = server.address();
+ if (address === null || typeof address === "string") throw new Error("no port");
+ try {
+ await run(address.port);
+ } finally {
+ server.closeAllConnections();
+ await new Promise<void>((resolve) => server.close(() => resolve()));
+ }
+}
+
+function realAuthFetch(port: number): AuthApi {
+ return loadWithStubs<AuthApi>(new URL("../src/features/auth/api.ts", import.meta.url), {
+ "@/lib/api-base": {
+ apiUrl: (path: string) => `http://127.0.0.1:${port}${path}`,
+ getApiPort: () => port,
+ isTauri: false,
+ },
+ "@/lib/account-transition": { accountTransitionPending: () => false },
+ "./session": {
+ clearAuthTokens: () => {},
+ getAuthToken: () => "access-token",
+ getRefreshToken: () => null,
+ mustChangePassword: () => false,
+ setMustChangePassword: () => {},
+ storeAuthTokens: () => {},
+ },
+ "@tauri-apps/api/core": {
+ invoke: async () => {
+ throw new Error("not Tauri");
+ },
+ },
+ });
+}
+
+function realLoadModel(auth: AuthApi): ChatApi {
+ return loadWithStubs<ChatApi>(new URL("../src/features/chat/api/chat-api.ts", import.meta.url), {
+ "@/features/auth": { authFetch: auth.authFetch },
+ "./padded-response": paddedResponse,
+ "@/lib/format-fastapi-error": {
+ formatApiErrorBody: (body: { detail?: unknown } | null) =>
+ typeof body?.detail === "string" ? body.detail : null,
+ },
+ "../types": {},
+ "../types/api": {},
+ "../utils/chat-history-revision": {
+ notifyChatHistoryUpdated: () => {},
+ isCoalescedHistoryEvent: () => false,
+ },
+ "../utils/load-warning-toast": { showLoadWarning: () => {} },
+ "./generation-length.ts": {},
+ "./gguf-variants-request": {},
+ "@/features/hf-auth": { prepareHfTokenForUse: async () => ({ proceed: true }) },
+ "@/features/igpu-carveout": {
+ dismissCarveoutAdviceForModel: () => {},
+ showCarveoutAdvice: () => {},
+ },
+ "@/features/hub/lib/abort-signals": {},
+ "@/features/hub/lib/hub-token-header": { hubTokenHeader: () => ({}) },
+ "@/features/hub/lib/network": { isHuggingFaceOffline: () => false },
+ "@/features/native-intents/api": { consumeNativePathToken: () => undefined },
+ "@/features/settings/low-disk-check": { checkDiskSpace: () => Promise.resolve() },
+ "@/lib/model-lifecycle-events": {
+ withModelLoadNotice: async (_r: string, _p: string | null, run: () => Promise<unknown>) =>
+ run(),
+ },
+ });
+}
+
+/** What performLoad's catch receives when this load's reply is `reply`. */
+async function loadError(reply: Reply): Promise<unknown> {
+ let caught: unknown = null;
+ await withLoadServer(reply, async (port) => {
+ const { loadModel } = realLoadModel(realAuthFetch(port));
+ try {
+ await loadModel({
+ model_path: "unsloth/gemma-3-270m-it-GGUF",
+ gguf_variant: "UD-Q4_K_XL",
+ max_seq_length: 4096,
+ });
+ } catch (error) {
+ caught = error;
+ }
+ });
+ return caught;
+}
+
+test("a load whose connection closed before any reply does not restore the previous model", async () => {
+ const error = await loadError("drop");
+ assert.ok(error instanceof Error, "the dropped load must reject");
+ assert.equal(loadOutcomeUnknown(error), true);
+ assert.equal(shouldRestorePreviousModel(error), false);
+});
+
+test("a padded load cut off mid-reply does not restore the previous model either", async () => {
+ const error = await loadError("padded-drop");
+ assert.ok(error instanceof Error, "the truncated load must reject");
+ assert.match((error as Error).message, /Model load did not report completion/);
+ assert.equal(loadOutcomeUnknown(error), true);
+ assert.equal(shouldRestorePreviousModel(error), false);
+});
+
+test("a failure the backend reported still restores the previous model", async () => {
+ for (const reply of ["rejected", "deferred"] as const) {
+ const error = await loadError(reply);
+ assert.ok(error instanceof Error, `${reply} must reject`);
+ assert.equal(loadOutcomeUnknown(error), false, reply);
+ assert.equal(shouldRestorePreviousModel(error), true, reply);
+ }
+});
+
+test("a completed load is not an error at all", async () => {
+ assert.equal(await loadError("loaded"), null);
+});
+
+test("non-errors and untagged errors keep the rollback", () => {
+ for (const value of [null, undefined, "boom", 0, {}, new Error("x"), new TypeError("x")]) {
+ assert.equal(shouldRestorePreviousModel(value), true, String(value));
+ }
+ assert.equal(
+ shouldRestorePreviousModel(Object.assign(new Error("x"), { unslothTransportFailure: "yes" })),
+ true,
+ );
+});
+
+test("performLoad only rolls back when the failed load was answered", () => {
+ // One rollback site, and its guard consults the helper before any request is sent.
+ const sites = RUNTIME.match(/const rollbackResponse = await loadModel\(/g) ?? [];
+ assert.equal(sites.length, 1);
+ const guarded =
+ /if \(\s*previousWasUnloaded &&\s*previousCheckpoint &&\s*shouldRestorePreviousModel\(error\)\s*\) \{[\s\S]*?const rollbackResponse = await loadModel\(/;
+ assert.match(RUNTIME, guarded);
+ // The failed load still surfaces: the guard skips the rollback, not the rethrow.
+ const catchBlock = RUNTIME.slice(
+ RUNTIME.indexOf("notifyLocalPromptQueueLoadFailed(lifecycleLease);"),
+ RUNTIME.indexOf("const isCachedLoad = downloadComplete;"),
+ );
+ assert.match(catchBlock, /\}\s*throw error;\s*\}\s*\}\s*$/);
+});