fix: resolve linting issues in kagent integration

- Define constants for repeated string literals (goconst)
- Fix detectKagentAPIVersion function signature to return single value
- Update function calls to match new signature
- Add nolint comments for test parallelization with env vars

This resolves all golangci-lint issues and ensures CI passes.

Author: JAORMX

cmd/thv-operator/README.md

@@ -177,7 +177,13 @@ kubectl describe mcpserver <name>
 
 ### Kagent Integration
 
-The ToolHive operator supports optional integration with [kagent](https://kagent.dev), allowing kagent agents to discover and use MCP servers managed by ToolHive. When enabled, the operator automatically creates kagent ToolServer resources that reference the ToolHive-managed MCP servers.
+The ToolHive operator supports optional integration with [kagent](https://kagent.dev), allowing kagent agents to discover and use MCP servers managed by ToolHive. When enabled, the operator automatically creates kagent resources that reference the ToolHive-managed MCP servers.
+
+The integration supports both:
+- **kagent v1alpha1**: Creates `ToolServer` resources
+- **kagent v1alpha2**: Creates `RemoteMCPServer` resources (when available)
+
+The operator automatically detects which kagent API version is available in your cluster and creates the appropriate resources.
 
 #### Enabling Kagent Integration
 
@@ -196,25 +202,43 @@ kagentIntegration:
   enabled: true
 ```
 
+#### Configuration Options
+
+You can control the kagent API version preference via environment variable:
+
+```yaml
+# In your values file
+kagentIntegration:
+  enabled: true
+  apiVersion: v1alpha2  # Optional: prefer v1alpha2 when available (defaults to v1alpha1)
+```
+
+This sets the `KAGENT_API_VERSION` environment variable in the operator deployment.
+
 #### How It Works
 
 When kagent integration is enabled:
 
-1. For each ToolHive MCPServer resource created, the operator automatically creates a corresponding kagent ToolServer resource
-2. The ToolServer resource references the ToolHive-managed MCP server service URL
-3. The ToolServer is owned by the MCPServer, ensuring it's deleted when the MCPServer is removed
-4. Kagent agents can then discover and use these ToolServers to access the MCP servers
+1. The operator detects which kagent API version is available in your cluster
+2. For each ToolHive MCPServer resource created, the operator automatically creates:
+   - A kagent `ToolServer` resource (v1alpha1), OR
+   - A kagent `RemoteMCPServer` resource (v1alpha2)
+3. The kagent resource references the ToolHive-managed MCP server service URL
+4. The resource is owned by the MCPServer, ensuring it's deleted when the MCPServer is removed
+5. Kagent agents can then discover and use these resources to access the MCP servers
 
-The kagent ToolServer resources are created with:
+The kagent resources are created with:
 - Name: `toolhive-<mcpserver-name>`
 - Namespace: Same as the MCPServer
-- Transport configuration: Mapped from ToolHive transport types (sse → sse, streamable-http → streamableHttp, stdio → sse)
+- Transport configuration:
+  - v1alpha1: Mapped to config types (sse → sse, streamable-http → streamableHttp, stdio → sse)
+  - v1alpha2: Mapped to protocols (sse → SSE, streamable-http → STREAMABLE_HTTP, stdio → SSE)
 - Service URL: Points to the ToolHive proxy service
 
 #### Requirements
 
-- Kagent must be installed in your cluster
-- The operator needs permissions to manage kagent ToolServer resources (automatically configured when integration is enabled)
+- Kagent must be installed in your cluster (either v1alpha1 or v1alpha2)
+- The operator needs permissions to manage kagent resources (automatically configured when integration is enabled)
 
 #### Example
 
@@ -232,8 +256,9 @@ spec:
   port: 8080
 ```
 
-With kagent integration enabled, the operator automatically creates:
+With kagent integration enabled, the operator automatically creates one of the following:
 
+**For kagent v1alpha1:**
 ```yaml
 apiVersion: kagent.dev/v1alpha1
 kind: ToolServer
@@ -251,7 +276,23 @@ spec:
       url: http://mcp-github-proxy.toolhive-system.svc.cluster.local:8080
 ```
 
-Kagent agents can then reference this ToolServer to use the GitHub MCP server in their workflows.
+**For kagent v1alpha2:**
+```yaml
+apiVersion: kagent.dev/v1alpha2
+kind: RemoteMCPServer
+metadata:
+  name: toolhive-github
+  namespace: toolhive-system
+  labels:
+    toolhive.stacklok.dev/managed-by: toolhive-operator
+    toolhive.stacklok.dev/mcpserver: github
+spec:
+  description: "ToolHive MCP Server: github"
+  url: http://mcp-github-proxy.toolhive-system.svc.cluster.local:8080
+  protocol: SSE
+```
+
+Kagent agents can then reference these resources to use the GitHub MCP server in their workflows.
 
 ### Permission Profiles
 

cmd/thv-operator/controllers/mcpserver_kagent.go

@@ -17,17 +17,22 @@ import (
 	mcpv1alpha1 "github.com/stacklok/toolhive/cmd/thv-operator/api/v1alpha1"
 )
 
+const (
+	kagentAPIVersionV1Alpha1 = "v1alpha1"
+	kagentAPIVersionV1Alpha2 = "v1alpha2"
+)
+
 // kagentToolServerGVK defines the GroupVersionKind for kagent v1alpha1 ToolServer
 var kagentToolServerGVK = schema.GroupVersionKind{
 	Group:   "kagent.dev",
-	Version: "v1alpha1",
+	Version: kagentAPIVersionV1Alpha1,
 	Kind:    "ToolServer",
 }
 
 // kagentRemoteMCPServerGVK defines the GroupVersionKind for kagent v1alpha2 RemoteMCPServer
 var kagentRemoteMCPServerGVK = schema.GroupVersionKind{
 	Group:   "kagent.dev",
-	Version: "v1alpha2",
+	Version: kagentAPIVersionV1Alpha2,
 	Kind:    "RemoteMCPServer",
 }
 
@@ -36,11 +41,11 @@ const (
 	// v1alpha1 config types
 	kagentConfigTypeSSE            = "sse"
 	kagentConfigTypeStreamableHTTP = "streamableHttp"
-	
+
 	// v1alpha2 protocol types
 	kagentProtocolSSE            = "SSE"
 	kagentProtocolStreamableHTTP = "STREAMABLE_HTTP"
-	
+
 	// Environment variable for kagent API version preference
 	kagentAPIVersionEnv = "KAGENT_API_VERSION"
 )
@@ -71,41 +76,41 @@ func getPreferredKagentAPIVersion() string {
 }
 
 // detectKagentAPIVersion detects which kagent API version is available in the cluster
-func (r *MCPServerReconciler) detectKagentAPIVersion(ctx context.Context) (string, error) {
+func (r *MCPServerReconciler) detectKagentAPIVersion(ctx context.Context) string {
 	// First check if user has a preference
 	preferred := getPreferredKagentAPIVersion()
-	
+
 	// Try to list resources of the preferred version to see if it's available
-	if preferred == "v1alpha2" {
+	if preferred == kagentAPIVersionV1Alpha2 {
 		// Try v1alpha2 RemoteMCPServer
 		list := &unstructured.UnstructuredList{}
 		list.SetGroupVersionKind(schema.GroupVersionKind{
 			Group:   "kagent.dev",
-			Version: "v1alpha2",
+			Version: kagentAPIVersionV1Alpha2,
 			Kind:    "RemoteMCPServerList",
 		})
-		
+
 		// We just want to check if the API exists, limit to 1 item
 		if err := r.List(ctx, list, &client.ListOptions{Limit: 1}); err == nil {
-			return "v1alpha2", nil
+			return kagentAPIVersionV1Alpha2
 		}
 	}
-	
+
 	// Try v1alpha1 ToolServer
 	list := &unstructured.UnstructuredList{}
 	list.SetGroupVersionKind(schema.GroupVersionKind{
 		Group:   "kagent.dev",
-		Version: "v1alpha1",
+		Version: kagentAPIVersionV1Alpha1,
 		Kind:    "ToolServerList",
 	})
-	
+
 	if err := r.List(ctx, list, &client.ListOptions{Limit: 1}); err == nil {
-		return "v1alpha1", nil
+		return kagentAPIVersionV1Alpha1
 	}
-	
+
 	// If neither works, return the preferred version anyway
 	// The actual resource creation will fail with a clear error
-	return preferred, nil
+	return preferred
 }
 
 // ensureKagentToolServer ensures a kagent resource exists for the ToolHive MCPServer
@@ -120,18 +125,14 @@ func (r *MCPServerReconciler) ensureKagentToolServer(ctx context.Context, mcpSer
 	}
 
 	// Detect which kagent API version to use
-	apiVersion, err := r.detectKagentAPIVersion(ctx)
-	if err != nil {
-		logger.Error(err, "Failed to detect kagent API version, using default", "default", apiVersion)
-	}
-
+	apiVersion := r.detectKagentAPIVersion(ctx)
 	logger.V(1).Info("Using kagent API version", "version", apiVersion)
 
 	// Create the appropriate kagent resource based on API version
 	var kagentResource *unstructured.Unstructured
 	var gvk schema.GroupVersionKind
-	
-	if apiVersion == "v1alpha2" {
+
+	if apiVersion == kagentAPIVersionV1Alpha2 {
 		kagentResource = r.createKagentRemoteMCPServerObject(mcpServer)
 		gvk = kagentRemoteMCPServerGVK
 	} else {
@@ -142,7 +143,7 @@ func (r *MCPServerReconciler) ensureKagentToolServer(ctx context.Context, mcpSer
 	// Check if the kagent resource already exists
 	existing := &unstructured.Unstructured{}
 	existing.SetGroupVersionKind(gvk)
-	err = r.Get(ctx, types.NamespacedName{
+	err := r.Get(ctx, types.NamespacedName{
 		Name:      kagentResource.GetName(),
 		Namespace: kagentResource.GetNamespace(),
 	}, existing)

cmd/thv-operator/controllers/mcpserver_kagent_test.go

@@ -199,12 +199,12 @@ func TestCreateKagentToolServerObjectStreamableHTTP(t *testing.T) {
 	assert.Equal(t, expectedURL, url)
 }
 
-func TestEnsureKagentToolServer(t *testing.T) {
+func TestEnsureKagentToolServer(t *testing.T) { //nolint:tparallel // Can't parallelize due to environment variable usage
 	t.Parallel()
 	// Create scheme with support for unstructured resources
 	scheme := runtime.NewScheme()
 	_ = mcpv1alpha1.AddToScheme(scheme)
-	
+
 	// Register kagent GVKs as unstructured types
 	// This allows the fake client to handle them even without the actual CRDs
 	// We need to add these to the scheme so the fake client knows about them
@@ -218,7 +218,7 @@ func TestEnsureKagentToolServer(t *testing.T) {
 		Version: "v1alpha2",
 		Kind:    "RemoteMCPServer",
 	}
-	
+
 	// Add the unstructured types to the scheme
 	scheme.AddKnownTypeWithName(kagentToolServerGVK, &unstructured.Unstructured{})
 	scheme.AddKnownTypeWithName(schema.GroupVersionKind{
@@ -247,7 +247,7 @@ func TestEnsureKagentToolServer(t *testing.T) {
 		},
 	}
 
-	t.Run("creates kagent ToolServer when enabled", func(t *testing.T) {
+	t.Run("creates kagent ToolServer when enabled", func(t *testing.T) { //nolint:paralleltest // Can't parallelize due to environment variable usage
 		// Don't run in parallel as environment variables are shared
 		// Enable kagent integration
 		os.Setenv("KAGENT_INTEGRATION_ENABLED", "true")
@@ -270,22 +270,22 @@ func TestEnsureKagentToolServer(t *testing.T) {
 		// In a real cluster with kagent CRDs installed, this would create the resource
 		// With the fake client, it will try to create but may not be able to verify
 		require.NoError(t, err)
-		
+
 		// Try to get the created resource using the client
 		kagentToolServer := &unstructured.Unstructured{}
 		kagentToolServer.SetGroupVersionKind(schema.GroupVersionKind{
 			Group:   "kagent.dev",
 			Version: "v1alpha1",
 			Kind:    "ToolServer",
 		})
-		
+
 		// Try to get the resource - this may fail with fake client
 		// but the important part is that ensureKagentToolServer didn't error
 		err = client.Get(context.Background(), types.NamespacedName{
 			Name:      "toolhive-test-mcp",
 			Namespace: "test-namespace",
 		}, kagentToolServer)
-		
+
 		// With fake client and unregistered CRDs, we expect this to fail
 		// but that's OK - the main test is that ensureKagentToolServer works
 		if err == nil {
@@ -294,7 +294,7 @@ func TestEnsureKagentToolServer(t *testing.T) {
 		}
 	})
 
-	t.Run("deletes kagent ToolServer when disabled", func(t *testing.T) {
+	t.Run("deletes kagent ToolServer when disabled", func(t *testing.T) { //nolint:paralleltest // Can't parallelize due to environment variable usage
 		// Don't run in parallel as environment variables are shared
 		// Disable kagent integration
 		os.Setenv("KAGENT_INTEGRATION_ENABLED", "false")