Add BackendRegistry interface for thread-safe backend access

Introduce BackendRegistry as a shared kernel component in pkg/vmcp to
provide thread-safe access to discovered backends across bounded contexts
(aggregator, router, health monitoring).

This implementation addresses the requirement to store full backend
information in routing tables, enabling the router to forward requests
without additional backend lookups.

Key changes:

- Create pkg/vmcp/registry.go with BackendRegistry interface
  * Get(ctx, backendID) - retrieve backend by ID
  * List(ctx) - get all backends
  * Count() - efficient backend count

- Implement immutableRegistry for Phase 1
  * Thread-safe for concurrent reads
  * Built once from discovered backends, never modified
  * Suitable for static backend lists in Phase 1

- Add BackendToTarget() helper function
  * Converts Backend to BackendTarget with full information
  * Populates WorkloadID, WorkloadName, BaseURL, TransportType,
    HealthStatus, AuthStrategy, and AuthMetadata

- Update aggregator to use BackendRegistry
  * Modify Aggregator.MergeCapabilities() to accept registry parameter
  * Refactor AggregateCapabilities() to create registry from backends
  * Populate routing table with complete BackendTarget information

- Enhance test coverage
  * Update TestDefaultAggregator_MergeCapabilities with registry
  * Add assertions verifying full BackendTarget population in routing table
  * Generate mocks for BackendRegistry interface

Design rationale:

Following DDD principles, BackendRegistry is placed in pkg/vmcp root as
a shared kernel component (like types.go and errors.go) to:
- Avoid circular dependencies between aggregator and router
- Provide single source of truth for backend information
- Enable reuse across multiple bounded contexts
- Support future evolution to mutable registry with health monitoring

The routing table now contains complete backend information needed for
request forwarding, eliminating the need for additional lookups during
routing (required for Issue #147).

Phase 1 uses immutableRegistry (read-only). Future phases can swap to
mutexRegistry for dynamic backend updates without API changes.

Related to Issue #148 (vMCP Capability Discovery & Querying)
Prepares for Issue #147 (Request Routing)

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

Co-Authored-By: Claude <noreply@anthropic.com>

Author: JAORMX

pkg/vmcp/aggregator/aggregator.go

@@ -45,7 +45,12 @@ type Aggregator interface {
 	ResolveConflicts(ctx context.Context, capabilities map[string]*BackendCapabilities) (*ResolvedCapabilities, error)
 
 	// MergeCapabilities creates the final unified capability view and routing table.
-	MergeCapabilities(ctx context.Context, resolved *ResolvedCapabilities) (*AggregatedCapabilities, error)
+	// Uses the backend registry to populate full BackendTarget information for routing.
+	MergeCapabilities(
+		ctx context.Context,
+		resolved *ResolvedCapabilities,
+		registry vmcp.BackendRegistry,
+	) (*AggregatedCapabilities, error)
 
 	// AggregateCapabilities is a convenience method that performs the full aggregation pipeline:
 	// 1. Query all backends

pkg/vmcp/aggregator/default_aggregator.go

@@ -172,9 +172,11 @@ func (*defaultAggregator) ResolveConflicts(
 }
 
 // MergeCapabilities creates the final unified capability view and routing table.
+// Uses the backend registry to populate full BackendTarget information for routing.
 func (*defaultAggregator) MergeCapabilities(
-	_ context.Context,
+	ctx context.Context,
 	resolved *ResolvedCapabilities,
+	registry vmcp.BackendRegistry,
 ) (*AggregatedCapabilities, error) {
 	logger.Debugf("Merging capabilities into final view")
 
@@ -195,25 +197,45 @@ func (*defaultAggregator) MergeCapabilities(
 			BackendID:   resolvedTool.BackendID,
 		})
 
-		// Add to routing table (we'll need to look up the backend target)
-		// For now, we'll create a minimal target with just the backend ID
-		// In a full implementation, we'd need to store backend targets during discovery
-		routingTable.Tools[resolvedTool.ResolvedName] = &vmcp.BackendTarget{
-			WorkloadID: resolvedTool.BackendID,
+		// Look up full backend information from registry
+		backend := registry.Get(ctx, resolvedTool.BackendID)
+		if backend == nil {
+			logger.Warnf("Backend %s not found in registry for tool %s, creating minimal target",
+				resolvedTool.BackendID, resolvedTool.ResolvedName)
+			routingTable.Tools[resolvedTool.ResolvedName] = &vmcp.BackendTarget{
+				WorkloadID: resolvedTool.BackendID,
+			}
+		} else {
+			// Use the backendToTarget helper from registry package
+			routingTable.Tools[resolvedTool.ResolvedName] = vmcp.BackendToTarget(backend)
 		}
 	}
 
 	// Add resources to routing table
 	for _, resource := range resolved.Resources {
-		routingTable.Resources[resource.URI] = &vmcp.BackendTarget{
-			WorkloadID: resource.BackendID,
+		backend := registry.Get(ctx, resource.BackendID)
+		if backend == nil {
+			logger.Warnf("Backend %s not found in registry for resource %s, creating minimal target",
+				resource.BackendID, resource.URI)
+			routingTable.Resources[resource.URI] = &vmcp.BackendTarget{
+				WorkloadID: resource.BackendID,
+			}
+		} else {
+			routingTable.Resources[resource.URI] = vmcp.BackendToTarget(backend)
 		}
 	}
 
 	// Add prompts to routing table
 	for _, prompt := range resolved.Prompts {
-		routingTable.Prompts[prompt.Name] = &vmcp.BackendTarget{
-			WorkloadID: prompt.BackendID,
+		backend := registry.Get(ctx, prompt.BackendID)
+		if backend == nil {
+			logger.Warnf("Backend %s not found in registry for prompt %s, creating minimal target",
+				prompt.BackendID, prompt.Name)
+			routingTable.Prompts[prompt.Name] = &vmcp.BackendTarget{
+				WorkloadID: prompt.BackendID,
+			}
+		} else {
+			routingTable.Prompts[prompt.Name] = vmcp.BackendToTarget(backend)
 		}
 	}
 
@@ -241,26 +263,31 @@ func (*defaultAggregator) MergeCapabilities(
 }
 
 // AggregateCapabilities is a convenience method that performs the full aggregation pipeline:
-// 1. Query all backends
-// 2. Resolve conflicts
-// 3. Merge into final view
+// 1. Create backend registry
+// 2. Query all backends
+// 3. Resolve conflicts
+// 4. Merge into final view with full backend information
 func (a *defaultAggregator) AggregateCapabilities(ctx context.Context, backends []vmcp.Backend) (*AggregatedCapabilities, error) {
 	logger.Infof("Starting capability aggregation for %d backends", len(backends))
 
-	// Step 1: Query all backends
+	// Step 1: Create registry from discovered backends
+	registry := vmcp.NewImmutableRegistry(backends)
+	logger.Debugf("Created backend registry with %d backends", registry.Count())
+
+	// Step 2: Query all backends
 	capabilities, err := a.QueryAllCapabilities(ctx, backends)
 	if err != nil {
 		return nil, fmt.Errorf("failed to query backends: %w", err)
 	}
 
-	// Step 2: Resolve conflicts
+	// Step 3: Resolve conflicts
 	resolved, err := a.ResolveConflicts(ctx, capabilities)
 	if err != nil {
 		return nil, fmt.Errorf("failed to resolve conflicts: %w", err)
 	}
 
-	// Step 3: Merge into final view
-	aggregated, err := a.MergeCapabilities(ctx, resolved)
+	// Step 4: Merge into final view with full backend information
+	aggregated, err := a.MergeCapabilities(ctx, resolved, registry)
 	if err != nil {
 		return nil, fmt.Errorf("failed to merge capabilities: %w", err)
 	}

pkg/vmcp/aggregator/default_aggregator_test.go

@@ -313,8 +313,27 @@ func TestDefaultAggregator_MergeCapabilities(t *testing.T) {
 			SupportsSampling: false,
 		}
 
+		// Create registry with test backends
+		backends := []vmcp.Backend{
+			{
+				ID:            "backend1",
+				Name:          "Backend 1",
+				BaseURL:       "http://backend1:8080",
+				TransportType: "streamable-http",
+				HealthStatus:  vmcp.BackendHealthy,
+			},
+			{
+				ID:            "backend2",
+				Name:          "Backend 2",
+				BaseURL:       "http://backend2:8080",
+				TransportType: "sse",
+				HealthStatus:  vmcp.BackendHealthy,
+			},
+		}
+		registry := vmcp.NewImmutableRegistry(backends)
+
 		agg := NewDefaultAggregator(nil)
-		aggregated, err := agg.MergeCapabilities(context.Background(), resolved)
+		aggregated, err := agg.MergeCapabilities(context.Background(), resolved, registry)
 
 		require.NoError(t, err)
 		assert.Len(t, aggregated.Tools, 2)
@@ -330,6 +349,22 @@ func TestDefaultAggregator_MergeCapabilities(t *testing.T) {
 		assert.Contains(t, aggregated.RoutingTable.Resources, "test://resource1")
 		assert.Contains(t, aggregated.RoutingTable.Prompts, "prompt1")
 
+		// Verify routing table has full backend information
+		tool1Target := aggregated.RoutingTable.Tools["tool1"]
+		assert.NotNil(t, tool1Target)
+		assert.Equal(t, "backend1", tool1Target.WorkloadID)
+		assert.Equal(t, "Backend 1", tool1Target.WorkloadName)
+		assert.Equal(t, "http://backend1:8080", tool1Target.BaseURL)
+		assert.Equal(t, "streamable-http", tool1Target.TransportType)
+		assert.Equal(t, vmcp.BackendHealthy, tool1Target.HealthStatus)
+
+		tool2Target := aggregated.RoutingTable.Tools["tool2"]
+		assert.NotNil(t, tool2Target)
+		assert.Equal(t, "backend2", tool2Target.WorkloadID)
+		assert.Equal(t, "Backend 2", tool2Target.WorkloadName)
+		assert.Equal(t, "http://backend2:8080", tool2Target.BaseURL)
+		assert.Equal(t, "sse", tool2Target.TransportType)
+
 		// Check metadata
 		assert.Equal(t, 2, aggregated.Metadata.ToolCount)
 		assert.Equal(t, 1, aggregated.Metadata.ResourceCount)