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: eject a model with a running chat from the Loaded models card (#14161)

Nilay4ea4c758dc27
diff --git a/studio/backend/hub/services/models/account_access.py b/studio/backend/hub/services/models/account_access.py
index ccf9657e537..cda199fe709 100644
--- a/studio/backend/hub/services/models/account_access.py
+++ b/studio/backend/hub/services/models/account_access.py
@@ -287,6 +287,16 @@ def _resident_loader(modality: str) -> str | None:
return gpu_arbiter.owner_account(modality) if gpu_arbiter.holds(modality) else None
+def shares_resident_with_others(modality: str) -> bool:
+ """Whether release_shared_resident would drop the caller's share, without dropping it."""
+ if not policy.installation_has_managed_accounts():
+ return False
+ account_id = current_account_id()
+ with _sharers_lock:
+ sharers = _resident_sharers.get(modality)
+ return bool(sharers) and account_id in sharers and len(sharers) > 1
+
+
def release_shared_resident(modality: str) -> bool:
"""Drop the caller's share while others keep the model; False leaves the share for a real unload."""
if not policy.installation_has_managed_accounts():
diff --git a/studio/backend/routes/inference.py b/studio/backend/routes/inference.py
index 09b6b2e50fc..37090ebc359 100644
--- a/studio/backend/routes/inference.py
+++ b/studio/backend/routes/inference.py
@@ -18262,7 +18262,16 @@ async def get_active_generations(
)
if slot is not None:
only, llama = set(slot.generations), slot.llama
- elif await asyncio.to_thread(model_slots.in_slot, None, lambda: _loaded_satisfies(model)):
+ elif await asyncio.to_thread(
+ model_slots.in_slot,
+ None,
+ # A cached standard-backend model counts as primary: /unload of it stops primary chats.
+ lambda: _loaded_satisfies(model)
+ or (
+ (standard := _peek_inference_backend()) is not None
+ and _unload_evicts_standard_backend(standard, model)
+ ),
+ ):
exclude |= model_slots.all_generations()
else:
only = set() # an absent model cannot interrupt any generation
@@ -22687,12 +22696,30 @@ async def _unload_model_impl(request: UnloadRequest, current_subject: str):
routed_slot.set(filling[0])
on_primary = routed_slot.get() is None
if on_primary:
- if (
+ sharing = (
request.cancel_load_request_id is None
and account_access.managed_account()
- and account_access.release_shared_resident("chat")
- ):
+ and account_access.shares_resident_with_others("chat")
+ )
+ if sharing and not await asyncio.to_thread(_loaded_satisfies, request.model_path):
+ # Another model's name must not drop this share, and the generic teardown below would
+ # clear every sharer's record of the shared model: answer the idempotent no-op.
return UnloadResponse(status = "unloaded", model = request.model_path)
+ if sharing:
+ # Leaving a share stops only this account's chats on it; the others keep theirs.
+ scope = account_access.account_scope()
+ elsewhere = model_slots.all_generations()
+ running = active_generations.count(scope, elsewhere, include_external = False)
+ if running and not request.force_cancel_active:
+ raise _active_generations_conflict(
+ "Unloading the model",
+ running,
+ active_generations.active_thread_ids(scope, elsewhere, include_external = False),
+ )
+ if account_access.release_shared_resident("chat"):
+ if running:
+ active_generations.cancel_all(scope, elsewhere, include_external = False)
+ return UnloadResponse(status = "unloaded", model = request.model_path)
account_access.require_resident_control(
"chat", _loaded_slot_ident() if account_access.managed_account() else None
)
diff --git a/studio/backend/tests/multi_account/test_chat_shared_resident.py b/studio/backend/tests/multi_account/test_chat_shared_resident.py
index 6e54133c97c..c7ad5826167 100644
--- a/studio/backend/tests/multi_account/test_chat_shared_resident.py
+++ b/studio/backend/tests/multi_account/test_chat_shared_resident.py
@@ -194,6 +194,46 @@ def test_a_sharer_leaving_keeps_the_model_for_the_others(monkeypatch, shared, ac
assert "chat" not in access._resident_sharers
+def test_a_sharer_leaving_mid_chat_is_refused_unless_forced_and_stops_only_its_chat(
+ monkeypatch, shared, accounts
+):
+ reuse_load(monkeypatch, accounts["alice"])
+ alice_run, bob_run = threading.Event(), threading.Event()
+ with (
+ run_as(accounts["alice"], active_generations.ActiveGeneration, alice_run),
+ run_as(accounts["bob"], active_generations.ActiveGeneration, bob_run),
+ ):
+ with client_for(accounts["alice"]) as client:
+ refused = client.post("/api/inference/unload", json = {"model_path": RESIDENT})
+ assert refused.status_code == 409, refused.text
+ assert sees_resident(accounts["alice"])
+ forced = client.post(
+ "/api/inference/unload",
+ json = {"model_path": RESIDENT, "force_cancel_active": True},
+ )
+ assert forced.status_code == 200, forced.text
+ assert alice_run.is_set()
+ assert not bob_run.is_set()
+ assert not shared.unloaded
+ assert not sees_resident(accounts["alice"])
+ assert sees_resident(accounts["bob"])
+
+
+def test_a_forced_unload_naming_another_model_stops_no_shared_chat(monkeypatch, shared, accounts):
+ reuse_load(monkeypatch, accounts["alice"])
+ alice_run = threading.Event()
+ with run_as(accounts["alice"], active_generations.ActiveGeneration, alice_run):
+ with client_for(accounts["alice"]) as client:
+ response = client.post(
+ "/api/inference/unload",
+ json = {"model_path": "someone/stale-gguf", "force_cancel_active": True},
+ )
+ assert response.status_code == 200, response.text
+ assert not alice_run.is_set()
+ assert not shared.unloaded
+ assert sees_resident(accounts["alice"])
+
+
def test_a_replacement_starts_the_sharers_afresh(monkeypatch, shared, accounts):
reuse_load(monkeypatch, accounts["alice"])
run_as(accounts["bob"], access.publish_resident, "chat", "bob/other-model")
diff --git a/studio/backend/tests/test_multi_model_serving.py b/studio/backend/tests/test_multi_model_serving.py
index 7a431c58b14..6483cb4e994 100644
--- a/studio/backend/tests/test_multi_model_serving.py
+++ b/studio/backend/tests/test_multi_model_serving.py
@@ -1115,6 +1115,29 @@ def test_active_generations_for_a_model_lists_only_its_chats(backends):
assert slots["parallel_slots"] == 4
+def test_active_generations_for_a_cached_primary_model_lists_the_primary_chats(
+ backends, monkeypatch
+):
+ _, extra = backends
+ standard = FakeOrchestrator("org/Active")
+ standard.models["org/Cached"] = {}
+ monkeypatch.setattr(orchestrator, "_inference_backend", standard)
+ monkeypatch.setattr(inf, "_llama_cpp_backend", FakeLlama())
+ app = FastAPI()
+ app.include_router(inf.studio_router, prefix = "/api/inference")
+ app.dependency_overrides[get_current_subject] = lambda: "test-subject"
+ on_primary, on_slot = threading.Event(), threading.Event()
+ extra.generations.add(on_slot)
+ with (
+ active_generations.ActiveGeneration(on_primary, thread_id = "chat-on-primary"),
+ active_generations.ActiveGeneration(on_slot, thread_id = "chat-on-B"),
+ TestClient(app) as client,
+ ):
+ get = lambda q: client.get("/api/inference/active-generations" + q).json()["thread_ids"]
+ assert get("?model=org/Cached") == ["chat-on-primary"]
+ assert get("?model=org/gone") == []
+
+
def test_an_integrated_gpu_keeps_its_free_memory_next_to_a_loaded_model():
from core.inference.llama_cpp import _net_of_held_vram
diff --git a/studio/frontend/scripts/check-bundle-budget.ts b/studio/frontend/scripts/check-bundle-budget.ts
index 26e789696bf..cbd10272d55 100644
--- a/studio/frontend/scripts/check-bundle-budget.ts
+++ b/studio/frontend/scripts/check-bundle-budget.ts
@@ -276,8 +276,10 @@ export const BUDGET = {
// its strings join the eager English catalog and settings search index. #14223 and #14232 add no raw bytes.
// Raised by that growth, to the measured build at 6ccf0e4e74 (6,842,532 B raw / 2,060,400 B transfer) plus a
// 160 B raw / 189 B transfer margin.
- transferBytes: 2_060_589,
- rawBytes: 6_842_692,
+ // The Loaded models card's eject confirmation (#14161, eager shell) adds 356 B raw / 158 B transfer over 28a222f20
+ // (6,842,874 B raw, 2,060,540 B transfer); limits = that build plus the same margin.
+ transferBytes: 2_060_729,
+ rawBytes: 6_843_034,
};
// The chunk count is reported but not budgeted. Splitting a page out of the entry raises it while lowering the
diff --git a/studio/frontend/src/features/chat/components/stop-running-chats-dialog.tsx b/studio/frontend/src/features/chat/components/stop-running-chats-dialog.tsx
index c69bbf2a813..37ed9b27d7a 100644
--- a/studio/frontend/src/features/chat/components/stop-running-chats-dialog.tsx
+++ b/studio/frontend/src/features/chat/components/stop-running-chats-dialog.tsx
@@ -37,10 +37,14 @@ export function StopRunningChatsDialog() {
const sharer = hasNonChat ? "request" : "conversation";
// Ejecting leaves no model loaded. Saying it "reloads the model" and offering "Stop and reload"
// promised the opposite of what confirming does, for the destructive one.
- const unloads = effect === "unload";
- const lead = unloads
- ? `${action || "Unloading the model"} leaves no model loaded, and every open ${sharer} shares it, `
- : `${action ? `${action} reloads the model, ` : "Reloading the model "}which every open ${sharer} shares, `;
+ const unloads = effect !== "reload";
+ // Model-neutral: a cached standard-backend unload also stops the active model's chats.
+ const lead =
+ effect === "unloadOne"
+ ? `${action || "Unloading this model"} cannot wait for running ${sharer}s, `
+ : unloads
+ ? `${action || "Unloading the model"} leaves no model loaded, and every open ${sharer} shares it, `
+ : `${action ? `${action} reloads the model, ` : "Reloading the model "}which every open ${sharer} shares, `;
const shown = titles.slice(0, 5);
const remaining = Math.max(0, titles.length - shown.length);
diff --git a/studio/frontend/src/features/chat/index.ts b/studio/frontend/src/features/chat/index.ts
index 822c082c184..dc91fdba2f2 100644
--- a/studio/frontend/src/features/chat/index.ts
+++ b/studio/frontend/src/features/chat/index.ts
@@ -259,6 +259,7 @@ export {
PROMPT_QUEUE_RUN_FAILED_EVENT,
PROMPT_QUEUE_STOP_EVENT,
requestLocalPromptQueueStop,
+ requestScopedLocalPromptQueueStop,
type PromptQueueRunFailedEventDetail,
type PromptQueueStopEventDetail,
} from "./utils/prompt-queue-boundary";
diff --git a/studio/frontend/src/features/chat/stores/stop-running-chats-dialog-store.ts b/studio/frontend/src/features/chat/stores/stop-running-chats-dialog-store.ts
index 01ccc76f439..520e87bafe8 100644
--- a/studio/frontend/src/features/chat/stores/stop-running-chats-dialog-store.ts
+++ b/studio/frontend/src/features/chat/stores/stop-running-chats-dialog-store.ts
@@ -5,8 +5,8 @@ import { create } from "zustand";
type Resolver = (confirmed: boolean) => void;
-/** What confirming does to the model: reload it, or leave none loaded. */
-export type StopRunningChatsEffect = "reload" | "unload";
+/** What confirming does: reload, leave no model loaded, or unload just this one. */
+export type StopRunningChatsEffect = "reload" | "unload" | "unloadOne";
// One at a time: a new request declines any pending one so no promise leaks.
let pendingResolver: Resolver | null = null;
diff --git a/studio/frontend/src/features/loaded-models/eject-chat-model.ts b/studio/frontend/src/features/loaded-models/eject-chat-model.ts
index be7906c0cf8..af700e4fe11 100644
--- a/studio/frontend/src/features/loaded-models/eject-chat-model.ts
+++ b/studio/frontend/src/features/loaded-models/eject-chat-model.ts
@@ -81,7 +81,11 @@ export async function ejectChatModel(
// else's.
const holdsTarget = (names: string[] | undefined) =>
names?.some((name) => deps.matches(target, name)) ?? false;
- if (deps.cachedRow || holdsTarget(await deps.readCached?.())) {
+ // Re-read even for a cached row: another tab may have evicted it since the card polled, and
+ // unloading a name nobody holds would still stop the active model's queues. A failed read
+ // keeps the row's own word, as before.
+ const cachedNow = await deps.readCached?.().catch(() => undefined);
+ if (cachedNow === undefined ? deps.cachedRow : holdsTarget(cachedNow)) {
// A cached row is never the active model, so the scoped read can never
// match it. Name it directly: the Transformers backend can still hold it.
await deps.unload(target);
diff --git a/studio/frontend/src/features/loaded-models/loaded-models-api.ts b/studio/frontend/src/features/loaded-models/loaded-models-api.ts
index f0bfd391d12..3e97270b9f7 100644
--- a/studio/frontend/src/features/loaded-models/loaded-models-api.ts
+++ b/studio/frontend/src/features/loaded-models/loaded-models-api.ts
@@ -8,8 +8,10 @@
import { authFetch } from "@/features/auth";
import {
+ confirmStopRunningChatsIfNeeded,
getInferenceStatus,
isExternalModelId,
+ requestScopedLocalPromptQueueStop,
resolveInferenceCheckpointId,
unloadModel,
useChatRuntimeStore,
@@ -152,6 +154,12 @@ export async function readLoadedModels(
/** Release the model this row names, and only that one. See eject-chat-model.ts. */
async function ejectChatRow(entry: LoadedModelEntry): Promise<EjectOutcome> {
+ const decision = await confirmStopRunningChatsIfNeeded(
+ "Unloading this model",
+ "unloadOne",
+ entry.name,
+ );
+ if (!decision.proceed) return { status: "declined" };
const { unloadedAliases, stillResident, replacedBy } = await ejectChatModel(
entry.name,
{
@@ -167,7 +175,14 @@ async function ejectChatRow(entry: LoadedModelEntry): Promise<EjectOutcome> {
),
};
},
- unload: (modelPath) => unloadModel({ model_path: modelPath }),
+ // Only once an unload is really sent: a row replaced since the poll unloads nothing.
+ unload: (modelPath) => {
+ requestScopedLocalPromptQueueStop(decision.promptQueueThreadIds);
+ return unloadModel({
+ model_path: modelPath,
+ force_cancel_active: decision.forceCancelActive,
+ });
+ },
matches: modelIdsMatch,
cachedRow: entry.inactive === true,
readCached: async () => (await bounded(getInferenceStatus)).loaded ?? [],
@@ -204,6 +219,7 @@ function clearChatSelectionFor(aliases: string[]): void {
export type EjectOutcome =
| { status: "ejected" }
| { status: "alreadyFree" }
+ | { status: "declined" }
| { status: "replaced"; resident: string }
| { status: "stillResident"; model: string }
// The unload was accepted but the read that confirms it did not answer, so neither "done" nor
diff --git a/studio/frontend/src/features/loaded-models/use-loaded-models.ts b/studio/frontend/src/features/loaded-models/use-loaded-models.ts
index cdb9d1b8183..6475d6cda1a 100644
--- a/studio/frontend/src/features/loaded-models/use-loaded-models.ts
+++ b/studio/frontend/src/features/loaded-models/use-loaded-models.ts
@@ -216,6 +216,7 @@ export function useLoadedModels(
const label = shortModelLabel(entry.name);
try {
const outcome = await ejectLoadedModel(entry);
+ if (outcome.status === "declined") return;
if (outcome.status === "stillResident") {
toast.warning(
`"${shortModelLabel(outcome.model)}" was loaded while ejecting, so it is still using memory. Eject again to release it.`,
diff --git a/studio/frontend/tests/helpers/loaded-models-eject-resolver.mjs b/studio/frontend/tests/helpers/loaded-models-eject-resolver.mjs
new file mode 100644
index 00000000000..d339487b1ce
--- /dev/null
+++ b/studio/frontend/tests/helpers/loaded-models-eject-resolver.mjs
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+// bundler-resolver's two rules, plus the barrels loaded-models-api.ts reaches that pull in
+// TSX: chat, images and video go to loaded-models-eject-stub.ts, auth to its store stub.
+import { resolve as resolveBundler } from "../bundler-resolver.mjs";
+
+const EJECT_STUB = new URL("./loaded-models-eject-stub.ts", import.meta.url)
+ .href;
+const STUBS = new Map([
+ ["@/features/chat", EJECT_STUB],
+ ["@/features/images/api", EJECT_STUB],
+ ["@/features/video/api", EJECT_STUB],
+ ["@/features/auth", new URL("./store-stubs/auth.ts", import.meta.url).href],
+]);
+
+export function resolve(specifier, context, next) {
+ const stub = STUBS.get(specifier);
+ if (stub) return next(stub, context);
+ return resolveBundler(specifier, context, next);
+}
diff --git a/studio/frontend/tests/helpers/loaded-models-eject-stub.ts b/studio/frontend/tests/helpers/loaded-models-eject-stub.ts
new file mode 100644
index 00000000000..f79707fbb36
--- /dev/null
+++ b/studio/frontend/tests/helpers/loaded-models-eject-stub.ts
@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+// Stubs the chat, images and video barrels; /unload 409s like the backend while a chat
+// is generating unless forced.
+
+type UnloadPayload = { model_path: string; force_cancel_active?: boolean };
+
+export const state = {
+ active: null as string | null,
+ loaded: [] as string[],
+ generating: false,
+ confirmAnswer: { proceed: true, forceCancelActive: false },
+ confirmCalls: [] as { action: string; effect: string; model?: string }[],
+ unloads: [] as UnloadPayload[],
+ queueStops: [] as string[][],
+};
+
+export function resetStub({
+ active = null as string | null,
+ loaded = [] as string[],
+ generating = false,
+} = {}): void {
+ state.active = active;
+ state.loaded = [...loaded];
+ state.generating = generating;
+ state.confirmAnswer = { proceed: true, forceCancelActive: false };
+ state.confirmCalls = [];
+ state.unloads = [];
+ state.queueStops = [];
+}
+
+export async function getInferenceStatus() {
+ return { active_model: state.active, loaded: [...state.loaded] };
+}
+
+export function resolveInferenceCheckpointId(status: {
+ active_model: string | null;
+}): string | null {
+ return status.active_model ?? null;
+}
+
+export function isExternalModelId() {
+ return false;
+}
+
+export async function unloadModel(payload: UnloadPayload): Promise<void> {
+ state.unloads.push(payload);
+ if (state.generating && !payload.force_cancel_active) {
+ throw new Error(
+ "Unloading this model would stop 1 chat that is still generating. Stop them first, or retry with force_cancel_active.",
+ );
+ }
+ state.generating = false;
+ state.loaded = state.loaded.filter((name) => name !== payload.model_path);
+ if (state.active === payload.model_path) state.active = null;
+}
+
+export async function confirmStopRunningChatsIfNeeded(
+ action: string,
+ effect: string,
+ model?: string,
+) {
+ state.confirmCalls.push({ action, effect, model });
+ const answer = state.generating
+ ? state.confirmAnswer
+ : { proceed: true, forceCancelActive: false };
+ const threads = state.generating ? ["running-thread"] : [];
+ return { ...answer, promptQueueThreadIds: threads, preStreamRunTokens: [] };
+}
+
+export function requestScopedLocalPromptQueueStop(threadIds: string[]) {
+ state.queueStops.push(threadIds);
+}
+
+export const useChatRuntimeStore = {
+ getState: () => ({ params: { checkpoint: null }, clearCheckpoint() {} }),
+};
+
+export async function getDiffusionStatus() {
+ return { loaded: false };
+}
+export async function unloadDiffusionModel() {
+ return { loaded: false };
+}
+export async function getVideoStatus() {
+ return { loaded: false };
+}
+export async function unloadVideoModel() {
+ return { loaded: false };
+}
diff --git a/studio/frontend/tests/loaded-models-eject-chat.test.ts b/studio/frontend/tests/loaded-models-eject-chat.test.ts
index e91db4df6cb..d28c429d69f 100644
--- a/studio/frontend/tests/loaded-models-eject-chat.test.ts
+++ b/studio/frontend/tests/loaded-models-eject-chat.test.ts
@@ -21,8 +21,9 @@ function resident(checkpoint: string): ResidentChatModel {
function backend(
timeline: (ResidentChatModel | null)[],
cachedRow = false,
- /** What the runtime still holds after a cached row's unload. */
+ /** What the runtime still holds after a cached row's unload; before it, the row itself too. */
cachedAfter: string[] | null = null,
+ cachedTarget = "unsloth/Qwen3-4B",
) {
const unloaded: string[] = [];
let read = 0;
@@ -35,7 +36,14 @@ function backend(
},
matches: modelIdsMatch,
cachedRow,
- ...(cachedAfter === null ? {} : { readCached: async () => cachedAfter }),
+ ...(cachedAfter === null
+ ? {}
+ : {
+ readCached: async () =>
+ cachedRow && unloaded.length === 0
+ ? [...cachedAfter, cachedTarget]
+ : cachedAfter,
+ }),
},
};
}
@@ -130,7 +138,11 @@ test("a cached row the backend kept is reported still resident", async () => {
const result = await ejectChatModel("unsloth/Qwen3-4B", deps);
assert.deepEqual(unloaded, ["unsloth/Qwen3-4B"], "the unload was attempted");
assert.equal(result.stillResident, "unsloth/Qwen3-4B");
- assert.deepEqual(result.unloadedAliases, [], "nothing to clear the picker on");
+ assert.deepEqual(
+ result.unloadedAliases,
+ [],
+ "nothing to clear the picker on",
+ );
});
test("a cached row the backend released is reported ejected", async () => {
diff --git a/studio/frontend/tests/loaded-models-eject-running-chats.test.ts b/studio/frontend/tests/loaded-models-eject-running-chats.test.ts
new file mode 100644
index 00000000000..d287d8295a9
--- /dev/null
+++ b/studio/frontend/tests/loaded-models-eject-running-chats.test.ts
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+// Ejecting a model with a running chat must send a forced unload, not surface the 409.
+
+import assert from "node:assert/strict";
+import { register } from "node:module";
+import test from "node:test";
+
+register("./helpers/loaded-models-eject-resolver.mjs", import.meta.url);
+
+const stub = await import("./helpers/loaded-models-eject-stub.ts");
+const { ejectLoadedModel } = await import(
+ "../src/features/loaded-models/loaded-models-api.ts"
+);
+
+const QWEN = "unsloth/Qwen3-4B-GGUF";
+const ORNITH = "ornith-ai/Ornith-1.5-35B-A3B-GGUF";
+
+function chatRow(name: string, inactive = false) {
+ return {
+ id: `chat:${name}`,
+ kind: "text" as const,
+ source: "chat" as const,
+ name,
+ detail: inactive ? "Still in memory" : "GGUF",
+ ...(inactive ? { inactive: true } : {}),
+ };
+}
+
+test("a generating model is ejected once stopping its chat is confirmed", async () => {
+ stub.resetStub({ active: QWEN, loaded: [QWEN], generating: true });
+ stub.state.confirmAnswer = { proceed: true, forceCancelActive: true };
+ const outcome = await ejectLoadedModel(chatRow(QWEN));
+ assert.deepEqual(stub.state.confirmCalls, [
+ { action: "Unloading this model", effect: "unloadOne", model: QWEN },
+ ]);
+ assert.equal(stub.state.unloads[0].force_cancel_active, true);
+ assert.deepEqual(stub.state.queueStops, [["running-thread"]]);
+ assert.deepEqual(outcome, { status: "ejected" });
+ assert.equal(stub.state.active, null);
+});
+
+test("a row replaced since the poll stops no queue and unloads nothing", async () => {
+ stub.resetStub({ active: ORNITH, loaded: [ORNITH], generating: true });
+ stub.state.confirmAnswer = { proceed: true, forceCancelActive: true };
+ const outcome = await ejectLoadedModel(chatRow(QWEN));
+ assert.deepEqual(stub.state.unloads, []);
+ assert.deepEqual(stub.state.queueStops, []);
+ assert.deepEqual(outcome, { status: "replaced", resident: ORNITH });
+});
+
+test("a generating model kept in memory beside the active one is ejected too", async () => {
+ stub.resetStub({ active: QWEN, loaded: [QWEN, ORNITH], generating: true });
+ stub.state.confirmAnswer = { proceed: true, forceCancelActive: true };
+ const outcome = await ejectLoadedModel(chatRow(ORNITH, true));
+ assert.deepEqual(stub.state.unloads, [
+ { model_path: ORNITH, force_cancel_active: true },
+ ]);
+ assert.deepEqual(outcome, { status: "ejected" });
+ assert.deepEqual(stub.state.loaded, [QWEN]);
+});
+
+test("a cached row another tab already evicted stops no queue", async () => {
+ stub.resetStub({ active: QWEN, loaded: [QWEN], generating: true });
+ stub.state.confirmAnswer = { proceed: true, forceCancelActive: true };
+ const outcome = await ejectLoadedModel(chatRow(ORNITH, true));
+ assert.deepEqual(stub.state.unloads, []);
+ assert.deepEqual(stub.state.queueStops, []);
+ assert.notEqual(outcome.status, "ejected");
+});
+
+test("declining to stop the chat leaves the model loaded", async () => {
+ stub.resetStub({ active: QWEN, loaded: [QWEN], generating: true });
+ stub.state.confirmAnswer = { proceed: false, forceCancelActive: false };
+ const outcome = await ejectLoadedModel(chatRow(QWEN));
+ assert.deepEqual(stub.state.unloads, []);
+ assert.deepEqual(outcome, { status: "declined" });
+ assert.equal(stub.state.active, QWEN);
+});
+
+test("an idle model is ejected without forcing anything", async () => {
+ stub.resetStub({ active: QWEN, loaded: [QWEN] });
+ const outcome = await ejectLoadedModel(chatRow(QWEN));
+ assert.equal(stub.state.unloads[0].force_cancel_active ?? false, false);
+ assert.deepEqual(outcome, { status: "ejected" });
+});