Implement tool conflict resolution for Virtual MCP Server

Add three conflict resolution strategies (prefix, priority, manual) to handle
duplicate tool names across multiple backend MCP servers in vMCP aggregation.

This implements the aggregation conflict resolution portion of the Virtual MCP
Server proposal (THV-2106), enabling vMCP to merge capabilities from multiple
backends while resolving naming conflicts.

Key features:
- Prefix strategy: automatically prefixes tools with workload identifier
  (supports {workload}_, {workload}., custom formats)
- Priority strategy: explicit ordering with first-wins semantics
  (drops lower-priority conflicting tools with warnings)
- Manual strategy: requires explicit overrides with startup validation
  (fails if any conflicts lack overrides, safest for production)
- Reuses existing mcp.WithToolsFilter/Override middleware logic
- Per-backend tool filtering and overrides applied before conflict resolution
- Tracks conflict metadata (count resolved, strategy used)

Implementation:
- Extracted shared filtering/override logic from pkg/mcp/tool_filter.go
- Created applyFilteringAndOverrides() as single source of truth
- Both HTTP middleware and aggregator use the same battle-tested code
- Updated defaultAggregator to integrate conflict resolver
- Comprehensive table-driven unit tests for all strategies

This follows DDD principles with clear bounded contexts and maintains
backward compatibility with existing middleware behavior.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: JAORMX

pkg/mcp/tool_filter.go

@@ -72,6 +72,36 @@ func (c *toolMiddlewareConfig) getToolListOverride(toolName string) (*toolOverri
 // middleware.
 type ToolMiddlewareOption func(*toolMiddlewareConfig) error
 
+// SimpleTool represents a minimal tool with name and description.
+// This is used by ApplyToolFiltering to work with tools in a generic way.
+type SimpleTool struct {
+	Name        string
+	Description string
+}
+
+// ApplyToolFiltering applies filtering and overriding to a list of tools.
+// This is the core logic used by both the HTTP middleware and other components
+// that need to apply the same filtering/overriding behavior.
+//
+// Returns the filtered and overridden tools.
+func ApplyToolFiltering(opts []ToolMiddlewareOption, tools []SimpleTool) ([]SimpleTool, error) {
+	config := &toolMiddlewareConfig{
+		filterTools:          make(map[string]struct{}),
+		actualToUserOverride: make(map[string]toolOverrideEntry),
+		userToActualOverride: make(map[string]toolOverrideEntry),
+	}
+
+	// Apply options to build config
+	for _, opt := range opts {
+		if err := opt(config); err != nil {
+			return nil, err
+		}
+	}
+
+	// Use the shared core logic
+	return applyFilteringAndOverrides(config, tools), nil
+}
+
 // WithToolsFilter is a function that can be used to configure the tool
 // middleware to use a filter list of tools.
 func WithToolsFilter(toolsFilter ...string) ToolMiddlewareOption {
@@ -448,7 +478,10 @@ func processToolsListResponse(
 	toolsListResponse toolsListResponse,
 	w io.Writer,
 ) error {
-	filteredTools := []map[string]any{}
+	// Convert to SimpleTool format for shared processing
+	simpleTools := make([]SimpleTool, 0, len(*toolsListResponse.Result.Tools))
+	toolMaps := make([]map[string]any, 0, len(*toolsListResponse.Result.Tools))
+
 	for _, tool := range *toolsListResponse.Result.Tools {
 		// NOTE: the spec does not allow for name to be missing.
 		toolName, ok := tool["name"].(string)
@@ -461,31 +494,86 @@ func processToolsListResponse(
 			return errToolNameNotFound
 		}
 
+		// Get description if present (optional in MCP spec)
+		description, _ := tool["description"].(string)
+
+		simpleTools = append(simpleTools, SimpleTool{
+			Name:        toolName,
+			Description: description,
+		})
+		toolMaps = append(toolMaps, tool)
+	}
+
+	// Apply the shared filtering/override logic
+	processedTools := applyFilteringAndOverrides(config, simpleTools)
+
+	// Build the filtered response by matching processed tools with their original maps
+	filteredTools := make([]map[string]any, 0, len(processedTools))
+	for _, processed := range processedTools {
+		// Find the original tool map by matching names
+		for i, simple := range simpleTools {
+			if simple.Name == processed.Name || simple.Name == findOriginalName(config, processed.Name) {
+				// Clone the original map and update name/description
+				toolCopy := make(map[string]any, len(toolMaps[i]))
+				for k, v := range toolMaps[i] {
+					toolCopy[k] = v
+				}
+				toolCopy["name"] = processed.Name
+				if processed.Description != "" {
+					toolCopy["description"] = processed.Description
+				}
+				filteredTools = append(filteredTools, toolCopy)
+				break
+			}
+		}
+	}
+
+	toolsListResponse.Result.Tools = &filteredTools
+	if err := json.NewEncoder(w).Encode(toolsListResponse); err != nil {
+		return fmt.Errorf("%w: %v", errBug, err)
+	}
+
+	return nil
+}
+
+// applyFilteringAndOverrides is the core logic for filtering and overriding tools.
+// This implements the exact same logic as before but is now extracted for reuse.
+func applyFilteringAndOverrides(config *toolMiddlewareConfig, tools []SimpleTool) []SimpleTool {
+	result := make([]SimpleTool, 0, len(tools))
+	for _, tool := range tools {
+		description := tool.Description
+
 		// If the tool is overridden, we need to use the override name and description.
-		if entry, ok := config.getToolListOverride(toolName); ok {
+		if entry, ok := config.getToolListOverride(tool.Name); ok {
 			if entry.OverrideName != "" {
-				tool["name"] = entry.OverrideName
+				tool.Name = entry.OverrideName
 			}
 			if entry.OverrideDescription != "" {
-				tool["description"] = entry.OverrideDescription
+				description = entry.OverrideDescription
 			}
-			toolName = entry.OverrideName
 		}
 
 		// If the tool is in the filter, we add it to the filtered tools list.
-		// Note that lookup is done using the user-known name, which might be
-		// different from the actual tool name.
-		if config.isToolInFilter(toolName) {
-			filteredTools = append(filteredTools, tool)
+		// Note that lookup is done using the user-known name (tool.Name after override).
+		if config.isToolInFilter(tool.Name) {
+			result = append(result, SimpleTool{
+				Name:        tool.Name,
+				Description: description,
+			})
 		}
 	}
+	return result
+}
 
-	toolsListResponse.Result.Tools = &filteredTools
-	if err := json.NewEncoder(w).Encode(toolsListResponse); err != nil {
-		return fmt.Errorf("%w: %v", errBug, err)
+// findOriginalName attempts to find the original tool name before override.
+func findOriginalName(config *toolMiddlewareConfig, overriddenName string) string {
+	// Iterate through overrides to find reverse mapping
+	for actualName, entry := range config.actualToUserOverride {
+		if entry.OverrideName == overriddenName {
+			return actualName
+		}
 	}
-
-	return nil
+	return overriddenName
 }
 
 // toolCallFix mimics a sum type in Go. The actual types represent the