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
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { register } from "node:module";
import { test } from "node:test";
import {
resolveEstimateContext,
resolveEstimateSourceIdentity,
resolveMlxEstimateContext,
resolveMlxServedWindow,
shouldRequestMemoryEstimate,
} from "../src/features/model-picker/model-config/estimate-context.ts";
// Auto sends 0 and llama.cpp fits the native context, not the displayed 32k fallback.
test("Auto with no metadata yet prices the native context, not the displayed 32k", () => {
assert.equal(resolveEstimateContext(null, null), 0);
});
test("an explicit length is priced as itself", () => {
assert.equal(resolveEstimateContext(8192, null), 8192);
assert.equal(resolveEstimateContext(524288, null), 524288);
});
test("the resident load's context is kept when reloading it", () => {
assert.equal(resolveEstimateContext(null, 40223), 40223);
});
test("a known native context is NOT quoted as the figure", () => {
// Not native: --fit can land below it, so 0 lets the estimate resolve it as the launch does.
assert.equal(resolveEstimateContext(null, null), 0);
});
test("an explicit length outranks the resident one", () => {
assert.equal(resolveEstimateContext(4096, 40223), 4096);
});
test("zero is not mistaken for unset", () => {
assert.equal(resolveEstimateContext(0, 40223), 0);
});
// Must include quantization: modelPath is identical across quant switches.
const sourceId = (
path: string,
variant: string | null = null,
token = "",
native: string | null = null,
) => resolveEstimateSourceIdentity(path, variant, token, native);
test("two quantizations of one repository are different sources", () => {
assert.notEqual(
sourceId("unsloth/Qwen3-8B-GGUF", "Q4_K_M"),
sourceId("unsloth/Qwen3-8B-GGUF", "F16"),
);
});
test("the same source is the same identity, so a slider step does not blank the row", () => {
assert.equal(
sourceId("unsloth/Qwen3-8B-GGUF", "Q4_K_M"),
sourceId("unsloth/Qwen3-8B-GGUF", "Q4_K_M"),
);
});
test("two repositories are different sources", () => {
assert.notEqual(sourceId("org/a", "Q4_K_M"), sourceId("org/b", "Q4_K_M"));
});
test("two credentials are different sources: they resolve different files", () => {
assert.notEqual(
sourceId("org/gated", "Q4_K_M", "aaa"),
sourceId("org/gated", "Q4_K_M", "bbb"),
);
});
test("two native picks of the same file name are different sources", () => {
assert.notEqual(
sourceId("model.gguf", null, "", "tok-1"),
sourceId("model.gguf", null, "", "tok-2"),
);
});
test("absent and null are the same, so an unset variant does not thrash the row", () => {
assert.equal(
sourceId("org/a", null),
sourceId("org/a", undefined as unknown as null),
);
});
// The fit path sends a pin or 0, never the resident length.
test("when the fit or a builtin-default owns the context, the resident length is not sent", () => {
assert.equal(resolveEstimateContext(null, 40960, true), 0);
});
test("a positive pin survives the fit path, because Load sends it", () => {
assert.equal(resolveEstimateContext(8192, 40960, true), 8192);
});
test("a non-positive pin is still 0 under the fit path", () => {
assert.equal(resolveEstimateContext(0, 40960, true), 0);
assert.equal(resolveEstimateContext(-1, 40960, true), 0);
});
test("every other shape keeps the resident fallback", () => {
assert.equal(resolveEstimateContext(null, 40960, false), 40960);
assert.equal(resolveEstimateContext(null, 40960), 40960);
});
test("a builtin-default GGUF load prices the fit, not the resident context", () => {
assert.equal(resolveEstimateContext(null, 131072, true), 0);
});
const gguf = (classifiedIsDiffusion: boolean | undefined) =>
shouldRequestMemoryEstimate({
isGguf: true,
isAppleUnifiedMemory: true,
classifiedIsDiffusion,
});
const safetensors = (
isAppleUnifiedMemory: boolean,
classifiedIsDiffusion: boolean | undefined,
) =>
shouldRequestMemoryEstimate({
isGguf: false,
isAppleUnifiedMemory,
classifiedIsDiffusion,
});
test("a GGUF is priced only once its probe has cleared it of being diffusion", () => {
assert.equal(gguf(false), true);
assert.equal(gguf(undefined), false);
});
test("an MLX load is priced without waiting for a GGUF-only probe", () => {
assert.equal(safetensors(true, undefined), true);
assert.equal(safetensors(true, false), true);
});
test("a model already known to be diffusion is priced by neither planner", () => {
assert.equal(gguf(true), false);
assert.equal(safetensors(true, true), false);
});
test("safetensors is not priced where MLX is not what would load it", () => {
assert.equal(safetensors(false, false), false);
assert.equal(safetensors(false, undefined), false);
});
register("./helpers/memory-estimate-resolver.mjs", import.meta.url);
const auth = await import("./helpers/store-stubs/auth.ts");
const native = await import("./helpers/native-path-stub.ts");
const { fetchMemoryEstimate, resetMemoryEstimateRouteMemo } = await import(
"../src/features/model-picker/api/memory-estimate.ts"
);
let sent: Record<string, unknown> | null = null;
test.beforeEach(() => {
resetMemoryEstimateRouteMemo();
native.setNativePathHandler(null);
sent = null;
auth.setAuthFetchHandler((_url, init) => {
sent = init?.body ? JSON.parse(String(init.body)) : null;
return new Response("{}", {
status: 200,
headers: { "Content-Type": "application/json" },
});
});
});
test.after(() => {
resetMemoryEstimateRouteMemo();
auth.setAuthFetchHandler(null);
native.setNativePathHandler(null);
});
test("the non-GGUF context and MLX cache width reach the backend", async () => {
await fetchMemoryEstimate({
modelPath: "mlx-community/Qwen3-8B-4bit",
maxSeqLength: 4096,
mlxKvQuant: "tq-4",
});
assert.equal(sent!.max_seq_length, 4096);
assert.equal(sent!.mlx_kv_quant, "tq-4");
});
test("every field sent is also a field the hook re-fetches for", () => {
const read = (path: string, fn: string): Set<string> => {
const source = readFileSync(new URL(path, import.meta.url), "utf8");
const start = source.indexOf(`function ${fn}(`);
assert.ok(start >= 0, `${fn} not found in ${path}; this test is stale`);
const body = source.slice(start, source.indexOf("\n}\n", start));
return new Set(
[...body.matchAll(/\b(?:payload|request)\.([A-Za-z0-9_]+)/g)].map(
(m) => m[1],
),
);
};
const wire = read(
"../src/features/model-picker/api/memory-estimate.ts",
"estimateRequestBody",
);
const key = read(
"../src/features/model-picker/hooks/use-memory-estimate.ts",
"estimateKey",
);
assert.ok(wire.has("maxSeqLength") && wire.has("mlxKvQuant"), "test is stale");
const unwatched = [...wire].filter((field) => !key.has(field));
assert.deepEqual(
unwatched,
[],
`sent to the backend but absent from estimateKey: ${unwatched.join(", ")}`,
);
});
test("what an MLX estimate names, and what the control shows", () => {
assert.equal(resolveMlxEstimateContext(null), 0);
assert.equal(resolveMlxEstimateContext(0), 0);
assert.equal(resolveMlxEstimateContext(8192), 8192);
assert.equal(resolveMlxServedWindow(8192, 24576, 262144), 24576);
assert.equal(resolveMlxServedWindow(null, 24576, 262144), 24576);
assert.equal(resolveMlxServedWindow(20480, null, 262144), 20480);
assert.equal(resolveMlxServedWindow(null, null, 262144), 262144);
assert.equal(resolveMlxServedWindow(null, null, null), null);
});
test("the fitted window survives the wire, and its absence reads as null", async () => {
const fitted = async (body: unknown) => {
auth.setAuthFetchHandler(() => Response.json(body));
return (await fetchMemoryEstimate({ modelPath: "a" })).contextFitted;
};
assert.equal(await fitted({ available: true, n_ctx: 24576, context_fitted: 24576 }), 24576);
assert.equal(await fitted({ available: true, n_ctx: 262144 }), null);
});