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.

7.8 KB
Raw Blame
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);
});