feat(kubevirt): Add vm_delete tool

Introduces a dedicated vm_delete tool to simplify VirtualMachine deletion.
Based on agent evaluation results, multiple agents were searching for a
vm_delete tool instead of using the generic resources_delete tool.

Assisted-By: Claude <[email protected]>
Signed-off-by: Lee Yarwood <[email protected]>

Author: lyarwood

pkg/toolsets/kubevirt/toolset.go

@@ -7,6 +7,7 @@ import (
 	internalk8s "github.com/containers/kubernetes-mcp-server/pkg/kubernetes"
 	"github.com/containers/kubernetes-mcp-server/pkg/toolsets"
 	vm_create "github.com/containers/kubernetes-mcp-server/pkg/toolsets/kubevirt/vm/create"
+	vm_delete "github.com/containers/kubernetes-mcp-server/pkg/toolsets/kubevirt/vm/delete"
 	vm_pause "github.com/containers/kubernetes-mcp-server/pkg/toolsets/kubevirt/vm/pause"
 	vm_start "github.com/containers/kubernetes-mcp-server/pkg/toolsets/kubevirt/vm/start"
 	vm_stop "github.com/containers/kubernetes-mcp-server/pkg/toolsets/kubevirt/vm/stop"
@@ -28,6 +29,7 @@ func (t *Toolset) GetDescription() string {
 func (t *Toolset) GetTools(o internalk8s.Openshift) []api.ServerTool {
 	return slices.Concat(
 		vm_create.Tools(),
+		vm_delete.Tools(),
 		vm_pause.Tools(),
 		vm_start.Tools(),
 		vm_stop.Tools(),

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

@@ -0,0 +1,88 @@
+package delete
+
+import (
+	"fmt"
+
+	"github.com/containers/kubernetes-mcp-server/pkg/api"
+	"github.com/google/jsonschema-go/jsonschema"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/dynamic"
+	"k8s.io/utils/ptr"
+)
+
+func Tools() []api.ServerTool {
+	return []api.ServerTool{
+		{
+			Tool: api.Tool{
+				Name:        "vm_delete",
+				Description: "Delete a VirtualMachine in the current cluster by providing its namespace and name",
+				InputSchema: &jsonschema.Schema{
+					Type: "object",
+					Properties: map[string]*jsonschema.Schema{
+						"namespace": {
+							Type:        "string",
+							Description: "The namespace of the virtual machine",
+						},
+						"name": {
+							Type:        "string",
+							Description: "The name of the virtual machine to delete",
+						},
+					},
+					Required: []string{"namespace", "name"},
+				},
+				Annotations: api.ToolAnnotations{
+					Title:           "Virtual Machine: Delete",
+					ReadOnlyHint:    ptr.To(false),
+					DestructiveHint: ptr.To(true),
+					IdempotentHint:  ptr.To(true),
+					OpenWorldHint:   ptr.To(false),
+				},
+			},
+			Handler: deleteVM,
+		},
+	}
+}
+
+func deleteVM(params api.ToolHandlerParams) (*api.ToolCallResult, error) {
+	// Parse required parameters
+	namespace, err := params.GetRequiredString("namespace")
+	if err != nil {
+		return api.NewToolCallResult("", err), nil
+	}
+
+	name, err := params.GetRequiredString("name")
+	if err != nil {
+		return api.NewToolCallResult("", err), nil
+	}
+
+	// Get dynamic client
+	restConfig := params.RESTConfig()
+	if restConfig == nil {
+		return api.NewToolCallResult("", fmt.Errorf("failed to get REST config")), nil
+	}
+
+	dynamicClient, err := dynamic.NewForConfig(restConfig)
+	if err != nil {
+		return api.NewToolCallResult("", fmt.Errorf("failed to create dynamic client: %w", err)), nil
+	}
+
+	// Define the VirtualMachine GVR
+	gvr := schema.GroupVersionResource{
+		Group:    "kubevirt.io",
+		Version:  "v1",
+		Resource: "virtualmachines",
+	}
+
+	// Delete the VM
+	err = dynamicClient.Resource(gvr).Namespace(namespace).Delete(
+		params.Context,
+		name,
+		metav1.DeleteOptions{},
+	)
+	if err != nil {
+		return api.NewToolCallResult("", fmt.Errorf("failed to delete VirtualMachine: %w", err)), nil
+	}
+
+	return api.NewToolCallResult(fmt.Sprintf("# VirtualMachine deleted successfully\nVirtualMachine '%s' in namespace '%s' has been deleted.", name, namespace), nil), nil
+}

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

@@ -0,0 +1,110 @@
+package delete_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/containers/kubernetes-mcp-server/pkg/api"
+	internalk8s "github.com/containers/kubernetes-mcp-server/pkg/kubernetes"
+	"github.com/containers/kubernetes-mcp-server/pkg/toolsets/kubevirt/vm/delete"
+)
+
+type mockToolCallRequest struct {
+	arguments map[string]interface{}
+}
+
+func (m *mockToolCallRequest) GetArguments() map[string]any {
+	return m.arguments
+}
+
+func TestDeleteParameterValidation(t *testing.T) {
+	tests := []struct {
+		name    string
+		args    map[string]interface{}
+		wantErr bool
+		errMsg  string
+	}{
+		{
+			name: "missing namespace parameter",
+			args: map[string]interface{}{
+				"name": "test-vm",
+			},
+			wantErr: true,
+			errMsg:  "namespace parameter required",
+		},
+		{
+			name: "missing name parameter",
+			args: map[string]interface{}{
+				"namespace": "test-ns",
+			},
+			wantErr: true,
+			errMsg:  "name parameter required",
+		},
+		{
+			name: "invalid namespace type",
+			args: map[string]interface{}{
+				"namespace": 123,
+				"name":      "test-vm",
+			},
+			wantErr: true,
+			errMsg:  "namespace parameter must be a string",
+		},
+		{
+			name: "invalid name type",
+			args: map[string]interface{}{
+				"namespace": "test-ns",
+				"name":      456,
+			},
+			wantErr: true,
+			errMsg:  "name parameter must be a string",
+		},
+		{
+			name: "valid parameters - cluster interaction expected",
+			args: map[string]interface{}{
+				"namespace": "test-ns",
+				"name":      "test-vm",
+			},
+			wantErr: true, // Will fail due to missing cluster connection, but parameters are valid
+		},
+	}
+
+	// Get the tool through the public API
+	tools := delete.Tools()
+	if len(tools) != 1 {
+		t.Fatalf("Expected 1 tool, got %d", len(tools))
+	}
+	vmDeleteTool := tools[0]
+
+	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},
+			}
+
+			// Call through the public Handler interface
+			result, err := vmDeleteTool.Handler(params)
+			if err != nil {
+				t.Errorf("Handler() unexpected Go error: %v", err)
+				return
+			}
+
+			if result == nil {
+				t.Error("Expected non-nil result")
+				return
+			}
+
+			// For parameter validation errors, check the error message
+			if tt.wantErr && tt.errMsg != "" {
+				if result.Error == nil {
+					t.Error("Expected error in result.Error, got nil")
+					return
+				}
+				if result.Error.Error() != tt.errMsg {
+					t.Errorf("Expected error message %q, got %q", tt.errMsg, result.Error.Error())
+				}
+			}
+		})
+	}
+}