Move group configuration Modelconfig collector group conf (#241)

* move config to modelconfigcollector

Signed-off-by: ronenkat <16743404+ronenkat@users.noreply.github.com>

* updated tests

Signed-off-by: ronenkat <16743404+ronenkat@users.noreply.github.com>

* address review

Signed-off-by: ronenkat <16743404+ronenkat@users.noreply.github.com>

* revert changes to requestcostmetadata/plugin_test.go

Signed-off-by: ronenkat <16743404+ronenkat@users.noreply.github.com>

---------

Signed-off-by: ronenkat <16743404+ronenkat@users.noreply.github.com>

Author: ronenkat

pkg/framework/interface/datalayer/modelgroups/modelgroups.go

@@ -0,0 +1,48 @@
+/*
+Copyright 2026 The llm-d Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package modelgroups defines the shared attribute key and Cloneable type used
+// to attach group membership to a Model in the datalayer. Producers (the
+// model-config-datasource plugin) publish a model's group names here; consumers
+// (the model-group-name-filter) read the same attribute to resolve "auto/<group>"
+// selectors, so the storage contract has a single source of truth.
+package modelgroups
+
+import (
+	"slices"
+
+	"github.com/llm-d/llm-d-inference-payload-processor/pkg/framework/interface/datalayer"
+)
+
+// GroupsAttributeKey is the AttributeMap key under which a model's Groups is
+// stored. A model with no group memberships does not have this attribute set.
+const GroupsAttributeKey = "model_groups"
+
+// Groups is a Cloneable list of group names a model belongs to. It is stored
+// in the Model's AttributeMap under GroupsAttributeKey.
+type Groups []string
+
+// Clone implements datalayer.Cloneable.
+func (g Groups) Clone() datalayer.Cloneable {
+	c := make(Groups, len(g))
+	copy(c, g)
+	return c
+}
+
+// Contains reports whether name appears in g.
+func (g Groups) Contains(name string) bool {
+	return slices.Contains(g, name)
+}

pkg/framework/plugins/datalayer/modelconfigcollector/plugin.go

@@ -29,6 +29,7 @@ import (
 
 	"github.com/llm-d/llm-d-inference-payload-processor/pkg/framework/interface/datalayer"
 	dlsrc "github.com/llm-d/llm-d-inference-payload-processor/pkg/framework/interface/datalayer/datasource"
+	"github.com/llm-d/llm-d-inference-payload-processor/pkg/framework/interface/datalayer/modelgroups"
 	"github.com/llm-d/llm-d-inference-payload-processor/pkg/framework/interface/datalayer/pricing"
 	"github.com/llm-d/llm-d-inference-payload-processor/pkg/framework/interface/plugin"
 )
@@ -54,9 +55,17 @@ type ModelConfiguration struct {
 	Pricing pricing.ModelPriceShape `json:"pricing"`
 }
 
+// ModelGroupConfig is a named group of model names in the config file. It is
+// used to populate each listed model's modelgroups.GroupsAttributeKey attribute.
+type ModelGroupConfig struct {
+	Name   string   `json:"name"`
+	Models []string `json:"models"`
+}
+
 // ModelsConfig is the schema of the JSON config file.
 type ModelsConfig struct {
 	Models []ModelConfiguration `json:"models"`
+	Groups []ModelGroupConfig   `json:"groups,omitempty"`
 }
 
 // ModelConfigDataSource watches a JSON file listing model names and keeps the
@@ -176,7 +185,8 @@ func (c *ModelConfigDataSource) Stop() {
 }
 
 // syncModels reads the config file, registers every valid listed model in the datastore,
-// and removes any datastore model that no longer appears in the file.
+// removes any datastore model that no longer appears in the file, and (re)populates each
+// model's group membership from the config's group-centric "groups" list.
 func (c *ModelConfigDataSource) syncModels(ctx context.Context) error {
 	logger := log.FromContext(ctx).WithName("model-config-datasource")
 
@@ -191,7 +201,32 @@ func (c *ModelConfigDataSource) syncModels(ctx context.Context) error {
 		return err
 	}
 
+	// membership maps a model name to the group names it belongs to, inverting the
+	// config's group-centric "groups" list ({name, models[]}) so it can be looked up
+	// per model below. Membership is only resolved against the "models" list once
+	// that loop below has run, so a group can reference a model before its validity
+	// as a model entry is known.
+	// A group with an empty name or an empty model list is invalid as the filter's
+	// "auto/<group-name>" syntax requires non-empty group-name.
+	// An individual empty model name within an otherwise valid group is
+	// skipped on its own.
+	membership := make(map[string]modelgroups.Groups)
+	for _, g := range cfg.Groups {
+		if g.Name == "" || len(g.Models) == 0 {
+			logger.Info("skipping invalid group configuration", "group", g.Name, "models", g.Models)
+			continue
+		}
+		for _, modelName := range g.Models {
+			if modelName == "" {
+				logger.Info("skipping empty model name in group configuration", "group", g.Name)
+				continue
+			}
+			membership[modelName] = append(membership[modelName], g.Name)
+		}
+	}
+
 	desired := make(map[string]struct{}, len(cfg.Models))
+	invalid := make(map[string]struct{}, len(cfg.Models))
 	for _, m := range cfg.Models {
 		if m.Name == "" {
 			logger.Info("skipping model entry with empty name")
@@ -202,11 +237,35 @@ func (c *ModelConfigDataSource) syncModels(ctx context.Context) error {
 				"model", m.Name,
 				"input_per_million", m.Pricing.InputPerMillion,
 				"output_per_million", m.Pricing.OutputPerMillion)
+			invalid[m.Name] = struct{}{}
 			continue
 		}
 		desired[m.Name] = struct{}{}
 		mdl := c.ds.GetOrCreateModel(m.Name)
 		mdl.GetAttributes().Put(pricing.TokenPricesAttributeKey, pricing.ToTokenPrices(m.Pricing))
+		// Refresh group membership alongside pricing so a model that lost all its
+		// group memberships in this reload doesn't keep a stale attribute.
+		if groups, ok := membership[m.Name]; ok {
+			mdl.GetAttributes().Put(modelgroups.GroupsAttributeKey, groups)
+		} else {
+			mdl.GetAttributes().Delete(modelgroups.GroupsAttributeKey)
+		}
+	}
+
+	// A group may reference a model name that isn't a valid "models" entry: either
+	// missing from "models" entirely, or present but itself skipped (empty name,
+	// negative price). Group membership never auto-creates a model, so just warn,
+	// distinguishing the two cases so the "invalid model" warning already logged
+	// above isn't mistaken for an unrelated "unknown model" one.
+	for modelName := range membership {
+		if _, ok := desired[modelName]; ok {
+			continue
+		}
+		if _, ok := invalid[modelName]; ok {
+			logger.Info("skipping invalid model referenced in group configuration", "model", modelName)
+		} else {
+			logger.Info("skipping unknown model in group configuration", "model", modelName)
+		}
 	}
 
 	for _, model := range c.ds.GetModels(datalayer.AllModelsPredicate) {