feat(kubevirt): Search namespaced preferences and instancetypes

Extend the VM creation tool to search for both cluster-wide and namespaced resources:

- Update searchPreferences to query:
  - VirtualMachineClusterPreference (cluster-wide)
  - VirtualMachinePreference (namespaced)

- Update searchInstancetypes to query:
  - VirtualMachineClusterInstancetype (cluster-wide)
  - VirtualMachineInstancetype (namespaced)

This allows the tool to discover and use namespaced preferences and instancetypes
in addition to cluster-wide resources, providing more flexibility for VM creation
in multi-tenant environments where resources may be scoped to specific namespaces.

The namespace context is passed from the VM creation request, enabling the search
to include resources from the target namespace where the VM will be created.

Assisted-By: Claude <noreply@anthropic.com>
Signed-off-by: Lee Yarwood <lyarwood@redhat.com>

Author: lyarwood

pkg/toolsets/kubevirt/vm/create/tool.go

@@ -121,7 +121,7 @@ func create(params api.ToolHandlerParams) (*api.ToolCallResult, error) {
 	matchedDataSource := matchDataSource(dataSources, createParams.Workload)
 
 	// Resolve preference from DataSource defaults or cluster resources
-	preference := resolvePreference(params, createParams.Preference, matchedDataSource, createParams.Workload)
+	preference := resolvePreference(params, createParams.Preference, matchedDataSource, createParams.Workload, createParams.Namespace)
 
 	// Resolve instancetype from DataSource defaults or size/performance hints
 	instancetype := resolveInstancetype(params, createParams, matchedDataSource)
@@ -140,13 +140,13 @@ func create(params api.ToolHandlerParams) (*api.ToolCallResult, error) {
 
 // createParameters holds parsed input parameters for VM creation
 type createParameters struct {
-	Namespace   string
-	Name        string
-	Workload    string
+	Namespace    string
+	Name         string
+	Workload     string
 	Instancetype string
-	Preference  string
-	Size        string
-	Performance string
+	Preference   string
+	Size         string
+	Performance  string
 }
 
 // parseCreateParameters parses and validates input parameters
@@ -205,7 +205,7 @@ func matchDataSource(dataSources []DataSourceInfo, workload string) *DataSourceI
 }
 
 // resolvePreference determines the preference to use from DataSource defaults or cluster resources
-func resolvePreference(params api.ToolHandlerParams, explicitPreference string, matchedDataSource *DataSourceInfo, workload string) string {
+func resolvePreference(params api.ToolHandlerParams, explicitPreference string, matchedDataSource *DataSourceInfo, workload string, namespace string) string {
 	// Use explicitly specified preference if provided
 	if explicitPreference != "" {
 		return explicitPreference
@@ -217,7 +217,7 @@ func resolvePreference(params api.ToolHandlerParams, explicitPreference string,
 	}
 
 	// Try to match preference name against the workload input
-	preferences := searchPreferences(params)
+	preferences := searchPreferences(params, namespace)
 	normalizedInput := strings.ToLower(strings.TrimSpace(workload))
 
 	for i := range preferences {
@@ -245,15 +245,15 @@ func resolveInstancetype(params api.ToolHandlerParams, createParams *createParam
 
 	// Match instancetype based on size and performance hints
 	if createParams.Size != "" {
-		return matchInstancetypeBySize(params, createParams.Size, createParams.Performance)
+		return matchInstancetypeBySize(params, createParams.Size, createParams.Performance, createParams.Namespace)
 	}
 
 	return ""
 }
 
 // matchInstancetypeBySize finds an instancetype that matches the size and performance hints
-func matchInstancetypeBySize(params api.ToolHandlerParams, size, performance string) string {
-	instancetypes := searchInstancetypes(params)
+func matchInstancetypeBySize(params api.ToolHandlerParams, size, performance, namespace string) string {
+	instancetypes := searchInstancetypes(params, namespace)
 	normalizedSize := strings.ToLower(strings.TrimSpace(size))
 	normalizedPerformance := strings.ToLower(strings.TrimSpace(performance))
 
@@ -637,8 +637,8 @@ func listDataSourcesFromNamespace(params api.ToolHandlerParams, dynamicClient dy
 	return results, nil
 }
 
-// searchPreferences searches for VirtualMachineClusterPreference resources in the cluster
-func searchPreferences(params api.ToolHandlerParams) []PreferenceInfo {
+// searchPreferences searches for both cluster-wide and namespaced VirtualMachinePreference resources
+func searchPreferences(params api.ToolHandlerParams, namespace string) []PreferenceInfo {
 	// Handle nil or invalid clients gracefully (e.g., in test environments)
 	if params.Kubernetes == nil {
 		return []PreferenceInfo{}
@@ -654,32 +654,45 @@ func searchPreferences(params api.ToolHandlerParams) []PreferenceInfo {
 		return []PreferenceInfo{}
 	}
 
-	// VirtualMachineClusterPreference GVR
-	preferenceGVR := schema.GroupVersionResource{
+	var results []PreferenceInfo
+
+	// Search for cluster-wide VirtualMachineClusterPreferences
+	clusterPreferenceGVR := schema.GroupVersionResource{
 		Group:    "instancetype.kubevirt.io",
 		Version:  "v1beta1",
 		Resource: "virtualmachineclusterpreferences",
 	}
 
-	// List VirtualMachineClusterPreferences
-	list, err := dynamicClient.Resource(preferenceGVR).List(params.Context, metav1.ListOptions{})
-	if err != nil {
-		// Preferences might not be available, return empty list
-		return []PreferenceInfo{}
+	clusterList, err := dynamicClient.Resource(clusterPreferenceGVR).List(params.Context, metav1.ListOptions{})
+	if err == nil {
+		for _, item := range clusterList.Items {
+			results = append(results, PreferenceInfo{
+				Name: item.GetName(),
+			})
+		}
 	}
 
-	var results []PreferenceInfo
-	for _, item := range list.Items {
-		results = append(results, PreferenceInfo{
-			Name: item.GetName(),
-		})
+	// Search for namespaced VirtualMachinePreferences
+	namespacedPreferenceGVR := schema.GroupVersionResource{
+		Group:    "instancetype.kubevirt.io",
+		Version:  "v1beta1",
+		Resource: "virtualmachinepreferences",
+	}
+
+	namespacedList, err := dynamicClient.Resource(namespacedPreferenceGVR).Namespace(namespace).List(params.Context, metav1.ListOptions{})
+	if err == nil {
+		for _, item := range namespacedList.Items {
+			results = append(results, PreferenceInfo{
+				Name: item.GetName(),
+			})
+		}
 	}
 
 	return results
 }
 
-// searchInstancetypes searches for VirtualMachineClusterInstancetype resources in the cluster
-func searchInstancetypes(params api.ToolHandlerParams) []InstancetypeInfo {
+// searchInstancetypes searches for both cluster-wide and namespaced VirtualMachineInstancetype resources
+func searchInstancetypes(params api.ToolHandlerParams, namespace string) []InstancetypeInfo {
 	// Handle nil or invalid clients gracefully (e.g., in test environments)
 	if params.Kubernetes == nil {
 		return []InstancetypeInfo{}
@@ -695,26 +708,40 @@ func searchInstancetypes(params api.ToolHandlerParams) []InstancetypeInfo {
 		return []InstancetypeInfo{}
 	}
 
-	// VirtualMachineClusterInstancetype GVR
-	instancetypeGVR := schema.GroupVersionResource{
+	var results []InstancetypeInfo
+
+	// Search for cluster-wide VirtualMachineClusterInstancetypes
+	clusterInstancetypeGVR := schema.GroupVersionResource{
 		Group:    "instancetype.kubevirt.io",
 		Version:  "v1beta1",
 		Resource: "virtualmachineclusterinstancetypes",
 	}
 
-	// List VirtualMachineClusterInstancetypes
-	list, err := dynamicClient.Resource(instancetypeGVR).List(params.Context, metav1.ListOptions{})
-	if err != nil {
-		// Instance types might not be available, return empty list
-		return []InstancetypeInfo{}
+	clusterList, err := dynamicClient.Resource(clusterInstancetypeGVR).List(params.Context, metav1.ListOptions{})
+	if err == nil {
+		for _, item := range clusterList.Items {
+			results = append(results, InstancetypeInfo{
+				Name:   item.GetName(),
+				Labels: item.GetLabels(),
+			})
+		}
 	}
 
-	var results []InstancetypeInfo
-	for _, item := range list.Items {
-		results = append(results, InstancetypeInfo{
-			Name:   item.GetName(),
-			Labels: item.GetLabels(),
-		})
+	// Search for namespaced VirtualMachineInstancetypes
+	namespacedInstancetypeGVR := schema.GroupVersionResource{
+		Group:    "instancetype.kubevirt.io",
+		Version:  "v1beta1",
+		Resource: "virtualmachineinstancetypes",
+	}
+
+	namespacedList, err := dynamicClient.Resource(namespacedInstancetypeGVR).Namespace(namespace).List(params.Context, metav1.ListOptions{})
+	if err == nil {
+		for _, item := range namespacedList.Items {
+			results = append(results, InstancetypeInfo{
+				Name:   item.GetName(),
+				Labels: item.GetLabels(),
+			})
+		}
 	}
 
 	return results