feat(kubevirt): Add autostart parameter to vm_create

Add optional autostart parameter to vm_create tool that sets runStrategy
to Always instead of Halted, allowing VMs to be created and started in
a single operation.

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

Author: lyarwood

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

@@ -7,6 +7,7 @@ import (
 	"text/template"
 
 	"github.com/containers/kubernetes-mcp-server/pkg/api"
+	"github.com/containers/kubernetes-mcp-server/pkg/output"
 	"github.com/google/jsonschema-go/jsonschema"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -20,15 +21,15 @@ const (
 	defaultPreferenceLabel   = "instancetype.kubevirt.io/default-preference"
 )
 
-//go:embed plan.tmpl
-var planTemplate string
+//go:embed vm.yaml.tmpl
+var vmYamlTemplate string
 
 func Tools() []api.ServerTool {
 	return []api.ServerTool{
 		{
 			Tool: api.Tool{
 				Name:        "vm_create",
-				Description: "Generate a comprehensive creation plan for a VirtualMachine, including pre-creation checks for instance types, preferences, and container disk images",
+				Description: "Create a VirtualMachine in the cluster with the specified configuration, automatically resolving instance types, preferences, and container disk images. VM will be created in Halted state by default; use autostart parameter to start it immediately.",
 				InputSchema: &jsonschema.Schema{
 					Type: "object",
 					Properties: map[string]*jsonschema.Schema{
@@ -63,13 +64,17 @@ func Tools() []api.ServerTool {
 							Description: "Optional performance family hint for the VM instance type (e.g., 'u1' for general-purpose, 'o1' for overcommitted, 'c1' for compute-optimized, 'm1' for memory-optimized). Defaults to 'u1' (general-purpose) if not specified.",
 							Examples:    []interface{}{"general-purpose", "overcommitted", "compute-optimized", "memory-optimized"},
 						},
+						"autostart": {
+							Type:        "boolean",
+							Description: "Optional flag to automatically start the VM after creation (sets runStrategy to Always instead of Halted). Defaults to false.",
+						},
 					},
 					Required: []string{"namespace", "name"},
 				},
 				Annotations: api.ToolAnnotations{
 					Title:           "Virtual Machine: Create",
-					ReadOnlyHint:    ptr.To(true),
-					DestructiveHint: ptr.To(false),
+					ReadOnlyHint:    ptr.To(false),
+					DestructiveHint: ptr.To(true),
 					IdempotentHint:  ptr.To(true),
 					OpenWorldHint:   ptr.To(false),
 				},
@@ -88,6 +93,7 @@ type vmParams struct {
 	UseDataSource       bool
 	DataSourceName      string
 	DataSourceNamespace string
+	RunStrategy         string
 }
 
 type DataSourceInfo struct {
@@ -129,13 +135,25 @@ func create(params api.ToolHandlerParams) (*api.ToolCallResult, error) {
 	// Build template parameters from resolved resources
 	templateParams := buildTemplateParams(createParams, matchedDataSource, instancetype, preference)
 
-	// Render the VM creation plan template
-	result, err := renderTemplate(templateParams)
+	// Render the VM YAML
+	vmYaml, err := renderVMYaml(templateParams)
 	if err != nil {
 		return api.NewToolCallResult("", err), nil
 	}
 
-	return api.NewToolCallResult(result, nil), nil
+	// Create the VM in the cluster
+	resources, err := params.ResourcesCreateOrUpdate(params, vmYaml)
+	if err != nil {
+		return api.NewToolCallResult("", fmt.Errorf("failed to create VirtualMachine: %w", err)), nil
+	}
+
+	// Format the output
+	marshalledYaml, err := output.MarshalYaml(resources)
+	if err != nil {
+		return api.NewToolCallResult("", fmt.Errorf("failed to marshal created VirtualMachine: %w", err)), nil
+	}
+
+	return api.NewToolCallResult("# VirtualMachine created successfully\n"+marshalledYaml, nil), nil
 }
 
 // createParameters holds parsed input parameters for VM creation
@@ -147,6 +165,7 @@ type createParameters struct {
 	Preference   string
 	Size         string
 	Performance  string
+	Autostart    bool
 }
 
 // parseCreateParameters parses and validates input parameters
@@ -167,6 +186,7 @@ func parseCreateParameters(params api.ToolHandlerParams) (*createParameters, err
 	}
 
 	performance := normalizePerformance(getOptionalString(params, "performance"))
+	autostart := getOptionalBool(params, "autostart")
 
 	return &createParameters{
 		Namespace:    namespace,
@@ -176,6 +196,7 @@ func parseCreateParameters(params api.ToolHandlerParams) (*createParameters, err
 		Preference:   getOptionalString(params, "preference"),
 		Size:         getOptionalString(params, "size"),
 		Performance:  performance,
+		Autostart:    autostart,
 	}, nil
 }
 
@@ -301,11 +322,18 @@ func filterInstancetypesBySize(instancetypes []InstancetypeInfo, normalizedSize
 
 // buildTemplateParams constructs the template parameters for VM creation
 func buildTemplateParams(createParams *createParameters, matchedDataSource *DataSourceInfo, instancetype, preference string) vmParams {
+	// Determine runStrategy based on autostart parameter
+	runStrategy := "Halted"
+	if createParams.Autostart {
+		runStrategy = "Always"
+	}
+
 	params := vmParams{
 		Namespace:    createParams.Namespace,
 		Name:         createParams.Name,
 		Instancetype: instancetype,
 		Preference:   preference,
+		RunStrategy:  runStrategy,
 	}
 
 	if matchedDataSource != nil && matchedDataSource.Namespace != "" {
@@ -324,9 +352,9 @@ func buildTemplateParams(createParams *createParameters, matchedDataSource *Data
 	return params
 }
 
-// renderTemplate renders the VM creation plan template
-func renderTemplate(templateParams vmParams) (string, error) {
-	tmpl, err := template.New("vm").Parse(planTemplate)
+// renderVMYaml renders the VM YAML from template
+func renderVMYaml(templateParams vmParams) (string, error) {
+	tmpl, err := template.New("vm").Parse(vmYamlTemplate)
 	if err != nil {
 		return "", fmt.Errorf("failed to parse template: %w", err)
 	}
@@ -398,6 +426,19 @@ func getOptionalString(params api.ToolHandlerParams, key string) string {
 	return str
 }
 
+func getOptionalBool(params api.ToolHandlerParams, key string) bool {
+	args := params.GetArguments()
+	val, ok := args[key]
+	if !ok {
+		return false
+	}
+	b, ok := val.(bool)
+	if !ok {
+		return false
+	}
+	return b
+}
+
 // resolveContainerDisk resolves OS names to container disk images from quay.io/containerdisks
 func resolveContainerDisk(input string) string {
 	// If input already looks like a container image, return as-is

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

@@ -1,40 +1,33 @@
 package create
 
 import (
-	"context"
 	"strings"
 	"testing"
-
-	"github.com/containers/kubernetes-mcp-server/pkg/api"
-	internalk8s "github.com/containers/kubernetes-mcp-server/pkg/kubernetes"
 )
 
-type mockToolCallRequest struct {
-	arguments map[string]interface{}
-}
-
-func (m *mockToolCallRequest) GetArguments() map[string]any {
-	return m.arguments
-}
-
-func TestCreate(t *testing.T) {
+// Test the YAML rendering directly without creating resources
+func TestRenderVMYaml(t *testing.T) {
 	tests := []struct {
 		name      string
-		args      map[string]interface{}
+		params    vmParams
 		wantErr   bool
 		checkFunc func(t *testing.T, result string)
 	}{
 		{
-			name: "creates VM with basic settings",
-			args: map[string]interface{}{
-				"namespace": "test-ns",
-				"name":      "test-vm",
-				"workload":  "fedora",
+			name: "renders VM with basic settings",
+			params: vmParams{
+				Namespace:     "test-ns",
+				Name:          "test-vm",
+				ContainerDisk: "quay.io/containerdisks/fedora:latest",
+				RunStrategy:   "Halted",
 			},
 			wantErr: false,
 			checkFunc: func(t *testing.T, result string) {
-				if !strings.Contains(result, "VirtualMachine Creation Plan") {
-					t.Errorf("Expected 'VirtualMachine Creation Plan' header in result")
+				if !strings.Contains(result, "apiVersion: kubevirt.io/v1") {
+					t.Errorf("Expected apiVersion in YAML")
+				}
+				if !strings.Contains(result, "kind: VirtualMachine") {
+					t.Errorf("Expected kind VirtualMachine in YAML")
 				}
 				if !strings.Contains(result, "name: test-vm") {
 					t.Errorf("Expected VM name test-vm in YAML")
@@ -51,12 +44,13 @@ func TestCreate(t *testing.T) {
 			},
 		},
 		{
-			name: "creates VM with instancetype",
-			args: map[string]interface{}{
-				"namespace":    "test-ns",
-				"name":         "test-vm",
-				"workload":     "ubuntu",
-				"instancetype": "u1.medium",
+			name: "renders VM with instancetype",
+			params: vmParams{
+				Namespace:     "test-ns",
+				Name:          "test-vm",
+				ContainerDisk: "quay.io/containerdisks/ubuntu:24.04",
+				Instancetype:  "u1.medium",
+				RunStrategy:   "Halted",
 			},
 			wantErr: false,
 			checkFunc: func(t *testing.T, result string) {
@@ -66,19 +60,20 @@ func TestCreate(t *testing.T) {
 				if !strings.Contains(result, "kind: VirtualMachineClusterInstancetype") {
 					t.Errorf("Expected VirtualMachineClusterInstancetype in YAML manifest")
 				}
-				// When instancetype is set, memory should not be in the YAML resources section
-				if strings.Contains(result, "resources:\n          requests:\n            memory:") {
-					t.Errorf("Should not have memory resources when instancetype is specified")
+				// When instancetype is set, memory should not be in the YAML
+				if strings.Contains(result, "guest: 2Gi") {
+					t.Errorf("Should not have guest memory when instancetype is specified")
 				}
 			},
 		},
 		{
-			name: "creates VM with preference",
-			args: map[string]interface{}{
-				"namespace":  "test-ns",
-				"name":       "test-vm",
-				"workload":   "rhel",
-				"preference": "rhel.9",
+			name: "renders VM with preference",
+			params: vmParams{
+				Namespace:     "test-ns",
+				Name:          "test-vm",
+				ContainerDisk: "registry.redhat.io/rhel9/rhel-guest-image:latest",
+				Preference:    "rhel.9",
+				RunStrategy:   "Halted",
 			},
 			wantErr: false,
 			checkFunc: func(t *testing.T, result string) {
@@ -91,11 +86,12 @@ func TestCreate(t *testing.T) {
 			},
 		},
 		{
-			name: "creates VM with custom container disk",
-			args: map[string]interface{}{
-				"namespace": "test-ns",
-				"name":      "test-vm",
-				"workload":  "quay.io/myrepo/myimage:v1.0",
+			name: "renders VM with custom container disk",
+			params: vmParams{
+				Namespace:     "test-ns",
+				Name:          "test-vm",
+				ContainerDisk: "quay.io/myrepo/myimage:v1.0",
+				RunStrategy:   "Halted",
 			},
 			wantErr: false,
 			checkFunc: func(t *testing.T, result string) {
@@ -105,68 +101,65 @@ func TestCreate(t *testing.T) {
 			},
 		},
 		{
-			name: "missing namespace",
-			args: map[string]interface{}{
-				"name":     "test-vm",
-				"workload": "fedora",
+			name: "renders VM with DataSource",
+			params: vmParams{
+				Namespace:           "test-ns",
+				Name:                "test-vm",
+				UseDataSource:       true,
+				DataSourceName:      "fedora",
+				DataSourceNamespace: "openshift-virtualization-os-images",
+				RunStrategy:         "Halted",
 			},
-			wantErr: true,
-		},
-		{
-			name: "missing name",
-			args: map[string]interface{}{
-				"namespace": "test-ns",
-				"workload":  "fedora",
+			wantErr: false,
+			checkFunc: func(t *testing.T, result string) {
+				if !strings.Contains(result, "dataVolumeTemplates") {
+					t.Errorf("Expected dataVolumeTemplates in YAML")
+				}
+				if !strings.Contains(result, "kind: DataSource") {
+					t.Errorf("Expected DataSource kind in YAML")
+				}
+				if !strings.Contains(result, "name: fedora") {
+					t.Errorf("Expected DataSource name in YAML")
+				}
+				if !strings.Contains(result, "openshift-virtualization-os-images") {
+					t.Errorf("Expected DataSource namespace in YAML")
+				}
 			},
-			wantErr: true,
 		},
 		{
-			name: "missing workload defaults to fedora",
-			args: map[string]interface{}{
-				"namespace": "test-ns",
-				"name":      "test-vm",
+			name: "renders VM with autostart (runStrategy Always)",
+			params: vmParams{
+				Namespace:     "test-ns",
+				Name:          "test-vm",
+				ContainerDisk: "quay.io/containerdisks/fedora:latest",
+				RunStrategy:   "Always",
 			},
 			wantErr: false,
 			checkFunc: func(t *testing.T, result string) {
-				if !strings.Contains(result, "quay.io/containerdisks/fedora:latest") {
-					t.Errorf("Expected default fedora container disk in result")
+				if !strings.Contains(result, "runStrategy: Always") {
+					t.Errorf("Expected runStrategy: Always in YAML")
 				}
 			},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			params := api.ToolHandlerParams{
-				Context:         context.Background(),
-				Kubernetes:      &internalk8s.Kubernetes{},
-				ToolCallRequest: &mockToolCallRequest{arguments: tt.args},
-			}
-
-			result, err := create(params)
-			if err != nil {
-				t.Errorf("create() unexpected Go error: %v", err)
-				return
-			}
-
-			if result == nil {
-				t.Error("Expected non-nil result")
-				return
-			}
+			result, err := renderVMYaml(tt.params)
 
 			if tt.wantErr {
-				if result.Error == nil {
-					t.Error("Expected error in result.Error, got nil")
+				if err == nil {
+					t.Error("Expected error, got nil")
 				}
 			} else {
-				if result.Error != nil {
-					t.Errorf("Expected no error in result, got: %v", result.Error)
+				if err != nil {
+					t.Errorf("Expected no error, got: %v", err)
 				}
-				if result.Content == "" {
-					t.Error("Expected non-empty result content")
+				if result == "" {
+					t.Error("Expected non-empty result")
 				}
 				if tt.checkFunc != nil {
-					tt.checkFunc(t, result.Content)
+					tt.checkFunc(t, result)
 				}
 			}
 		})