feat(gallery): drop the redundant variant min_memory field

Variant.MinMemory was an authored override for when the live probe misreads
a variant's footprint. It duplicated an existing field: probeEntryMemory
already passes the entry's declared size: into EstimateModelMultiContext,
whose cascade prefers that declared size over its own guesswork. Correcting
size: on the referenced entry fixes the figure for every consumer rather
than only for variant selection, so min_memory shadowed the right answer.

A variant is now nothing but a name. Its effective size is exactly the probe
result, and an unknown stays unknown: it survives the filter and ranks last.

EffectiveMemory loses its error return along with the field. The authored
string was the only thing that could fail to parse, so the error had no
remaining source and was propagating dead nil-checks through SelectVariant,
DescribeVariants and the pin warning.

Selection behaviour is unchanged. The specs covering probe-derived sizing,
ranking, filtering, the unknown-size path, pin recall, entry/variant
metadata split and deep-copy isolation all survive; the three install specs
that needed a definite size now declare it through the referenced entry's
own size:, which exercises the documented escape hatch directly.

gallery/index.yaml is untouched: no entry ever carried the key.

Assisted-by: Claude:claude-opus-4-8
Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

Author: mudler

.agents/adding-gallery-models.md

@@ -119,10 +119,11 @@ Rules:
   and installs the largest survivor, falling back to the declaring entry's own
   build. Sizes are measured live from the weights and cached, so nothing has to
   be written down.
-- `min_memory` on a single variant (e.g. `min_memory: 20GiB`) overrides the
-  measured size and suppresses the measurement for that variant. Use it only
-  when you have measured a real load and know the estimate is wrong; most
-  variants should not carry it.
+- A variant is nothing but a name; there is no per-variant memory field. When
+  the measured size for a build is wrong, correct it on the referenced entry by
+  setting that entry's own `size:` (e.g. `size: "20GiB"`). The estimator prefers
+  a declared size over its own guesswork, so the fix applies everywhere the size
+  is shown or compared rather than only to variant selection.
 
 Users can override the automatic choice with `variant` on `POST /models/apply`,
 `local-ai models install --variant`, or the `install_model` MCP tool. See

core/gallery/describe_variants.go

@@ -63,10 +63,7 @@ func DescribeVariants(models []*GalleryModel, entry *GalleryModel, env ResolveEn
 
 	views := make([]VariantView, 0, len(options))
 	for _, o := range options {
-		memory, known, err := o.EffectiveMemory()
-		if err != nil {
-			return nil, err
-		}
+		memory, known := o.EffectiveMemory()
 		view := VariantView{
 			Model:   o.Variant.Model,
 			Backend: o.Backend,

core/gallery/describe_variants_test.go

@@ -124,17 +124,6 @@ var _ = Describe("DescribeVariants", func() {
 			Expect(byName(view, "qwen3-8b-gguf-q8").MemoryBytes).To(Equal(gib(9)))
 		})
 
-		It("lets an authored min_memory win over the probe and skips that probe", func() {
-			base.Variants = []gallery.Variant{{Model: "qwen3-8b-vllm-awq", MinMemory: "20GiB"}}
-
-			view, err := gallery.DescribeVariants(models, base, probing(gib(24), map[string]uint64{
-				"qwen3-8b-vllm-awq": gib(2),
-			}))
-			Expect(err).ToNot(HaveOccurred())
-			Expect(byName(view, "qwen3-8b-vllm-awq").MemoryBytes).To(Equal(gib(20)))
-			Expect(probed).ToNot(ContainElement("qwen3-8b-vllm-awq"))
-		})
-
 		It("reports a size it could not determine as unknown rather than as free", func() {
 			// Zero on the wire means unknown. Rendering it as a zero-byte model
 			// would advertise the largest download on offer as costless.

core/gallery/models.go

@@ -105,9 +105,7 @@ func variantOptions(models []*GalleryModel, entry *GalleryModel, env ResolveEnv)
 		}
 
 		option := VariantOption{Variant: v, Backend: target.Backend}
-		// An authored figure short circuits the probe: the author already
-		// answered the question the probe would spend a round trip asking.
-		if v.MinMemory == "" && env.ProbeMemory != nil {
+		if env.ProbeMemory != nil {
 			option.ProbedMemory = env.ProbeMemory(target)
 		}
 		options = append(options, option)
@@ -206,7 +204,7 @@ func ResolveVariant(models []*GalleryModel, entry *GalleryModel, env ResolveEnv,
 	// checks, but a silent bypass makes a later out-of-memory failure
 	// impossible to trace back to the pin, so it is recorded loudly here.
 	if pin != "" {
-		if need, known, verr := selected.EffectiveMemory(); verr == nil && known && env.AvailableMemory < need {
+		if need, known := selected.EffectiveMemory(); known && env.AvailableMemory < need {
 			xlog.Warn("Pinned model variant declares more memory than this system reports; installing anyway because the pin overrides hardware resolution",
 				"model", entry.Name, "variant", selected.Variant.Model, "required_memory", need, "available_memory", env.AvailableMemory)
 		}

core/gallery/resolve_variant.go

@@ -31,9 +31,10 @@ type VariantOption struct {
 	// must stay installable on every host and for every client.
 	IsBase bool
 	// ProbedMemory is the footprint measured live from the referenced entry's
-	// weights, in bytes. It is only consulted when the variant declares no
-	// min_memory of its own, because a human who measured a real load knows
-	// more than a pre-download estimate does.
+	// weights, in bytes. It is the only source of a variant's size. An author
+	// who needs to correct a bad estimate sets `size:` on the referenced entry,
+	// which the estimator behind the probe already prefers over its own
+	// guesswork, so the correction lands everywhere the size is used.
 	//
 	// Zero means the probe could not determine a size. That is an unknown, not
 	// a zero requirement: a probe that cannot reach the network must never be
@@ -42,17 +43,12 @@ type VariantOption struct {
 }
 
 // EffectiveMemory returns this option's memory requirement in bytes and whether
-// one is known at all: the authored figure when there is one, else the live
-// probe result, else nothing.
-func (o VariantOption) EffectiveMemory() (uint64, bool, error) {
-	size, known, err := o.Variant.AuthoredMinMemory()
-	if err != nil || known {
-		return size, known, err
-	}
+// one is known at all.
+func (o VariantOption) EffectiveMemory() (uint64, bool) {
 	if o.ProbedMemory > 0 {
-		return o.ProbedMemory, true, nil
+		return o.ProbedMemory, true
 	}
-	return 0, false, nil
+	return 0, false
 }
 
 // ResolveEnv describes the host a variant is selected for.
@@ -69,13 +65,12 @@ type ResolveEnv struct {
 	// caller with no view of the hardware.
 	BackendCompatible func(backend string) bool
 	// ProbeMemory measures how much memory a referenced gallery entry needs,
-	// without downloading it. It is consulted only for variants that declare no
-	// min_memory, and a zero result means "could not tell", never "needs
-	// nothing".
+	// without downloading it. A zero result means "could not tell", never
+	// "needs nothing".
 	//
 	// It is a func field rather than a live network handle so specs can pin an
 	// exact size, or an exact failure, without reaching the internet. A nil func
-	// leaves every unauthored variant unknown, which selection already handles.
+	// leaves every variant unknown, which selection already handles.
 	//
 	// SelectVariant never calls this: the install layer resolves every size into
 	// VariantOption.ProbedMemory first, so the selector stays pure.
@@ -149,10 +144,7 @@ func SelectVariant(options []VariantOption, env ResolveEnv, pin string) (Variant
 			continue
 		}
 
-		memory, known, err := o.EffectiveMemory()
-		if err != nil {
-			return VariantSelection{}, err
-		}
+		memory, known := o.EffectiveMemory()
 		if known && memory > env.AvailableMemory {
 			reasons = append(reasons, fmt.Sprintf("%s needs %s of memory", o.Variant.Model, humanBytes(memory)))
 			continue