Add map indexes for O(1) lookups in Registry

Address review feedback to use maps for collections. Added lookup maps
(toolsByName, resourcesByURI, promptsByName) while keeping slices for
ordered iteration. This provides O(1) lookup for:

- FindToolByName
- filterToolsByName (used by ForMCPRequest)
- filterResourcesByURI
- filterPromptsByName

Maps are built once during Build() and shared in ForMCPRequest copies.

Author: SamMorrowDrums

.gitignore

@@ -19,4 +19,5 @@ bin/
 # binary
 github-mcp-server
 
-.historyconformance-report/
+.history
+conformance-report/

pkg/registry/builder.go

@@ -1,6 +1,7 @@
 package registry
 
 import (
+	"sort"
 	"strings"
 )
 
@@ -124,8 +125,10 @@ func (b *Builder) Build() *Registry {
 		featureChecker:    b.featureChecker,
 	}
 
-	// Process toolsets
-	r.enabledToolsets, r.unrecognizedToolsets = b.processToolsets()
+	// Note: toolsByName map is lazy-initialized on first use via getToolsByName()
+
+	// Process toolsets and pre-compute metadata in a single pass
+	r.enabledToolsets, r.unrecognizedToolsets, r.toolsetIDs, r.defaultToolsetIDs, r.toolsetDescriptions = b.processToolsets()
 
 	// Process additional tools (resolve aliases)
 	if len(b.additionalTools) > 0 {
@@ -146,25 +149,65 @@ func (b *Builder) Build() *Registry {
 // processToolsets processes the toolsetIDs configuration and returns:
 // - enabledToolsets map (nil means all enabled)
 // - unrecognizedToolsets list for warnings
-func (b *Builder) processToolsets() (map[ToolsetID]bool, []string) {
-	// Build a set of valid toolset IDs for validation
+// - allToolsetIDs sorted list of all toolset IDs
+// - defaultToolsetIDs sorted list of default toolset IDs
+// - toolsetDescriptions map of toolset ID to description
+func (b *Builder) processToolsets() (map[ToolsetID]bool, []string, []ToolsetID, []ToolsetID, map[ToolsetID]string) {
+	// Single pass: collect all toolset metadata together
 	validIDs := make(map[ToolsetID]bool)
-	for _, t := range b.tools {
+	defaultIDs := make(map[ToolsetID]bool)
+	descriptions := make(map[ToolsetID]string)
+
+	for i := range b.tools {
+		t := &b.tools[i]
 		validIDs[t.Toolset.ID] = true
+		if t.Toolset.Default {
+			defaultIDs[t.Toolset.ID] = true
+		}
+		if t.Toolset.Description != "" {
+			descriptions[t.Toolset.ID] = t.Toolset.Description
+		}
 	}
-	for _, r := range b.resourceTemplates {
+	for i := range b.resourceTemplates {
+		r := &b.resourceTemplates[i]
 		validIDs[r.Toolset.ID] = true
+		if r.Toolset.Default {
+			defaultIDs[r.Toolset.ID] = true
+		}
+		if r.Toolset.Description != "" {
+			descriptions[r.Toolset.ID] = r.Toolset.Description
+		}
 	}
-	for _, p := range b.prompts {
+	for i := range b.prompts {
+		p := &b.prompts[i]
 		validIDs[p.Toolset.ID] = true
+		if p.Toolset.Default {
+			defaultIDs[p.Toolset.ID] = true
+		}
+		if p.Toolset.Description != "" {
+			descriptions[p.Toolset.ID] = p.Toolset.Description
+		}
+	}
+
+	// Build sorted slices from the collected maps
+	allToolsetIDs := make([]ToolsetID, 0, len(validIDs))
+	for id := range validIDs {
+		allToolsetIDs = append(allToolsetIDs, id)
+	}
+	sort.Slice(allToolsetIDs, func(i, j int) bool { return allToolsetIDs[i] < allToolsetIDs[j] })
+
+	defaultToolsetIDList := make([]ToolsetID, 0, len(defaultIDs))
+	for id := range defaultIDs {
+		defaultToolsetIDList = append(defaultToolsetIDList, id)
 	}
+	sort.Slice(defaultToolsetIDList, func(i, j int) bool { return defaultToolsetIDList[i] < defaultToolsetIDList[j] })
 
 	toolsetIDs := b.toolsetIDs
 
 	// Check for "all" keyword - enables all toolsets
 	for _, id := range toolsetIDs {
 		if strings.TrimSpace(id) == "all" {
-			return nil, nil // nil means all enabled
+			return nil, nil, allToolsetIDs, defaultToolsetIDList, descriptions // nil means all enabled
 		}
 	}
 
@@ -184,7 +227,7 @@ func (b *Builder) processToolsets() (map[ToolsetID]bool, []string) {
 			continue
 		}
 		if trimmed == "default" {
-			for _, defaultID := range b.defaultToolsetIDs() {
+			for _, defaultID := range defaultToolsetIDList {
 				if !seen[defaultID] {
 					seen[defaultID] = true
 					expanded = append(expanded, defaultID)
@@ -204,38 +247,12 @@ func (b *Builder) processToolsets() (map[ToolsetID]bool, []string) {
 	}
 
 	if len(expanded) == 0 {
-		return make(map[ToolsetID]bool), unrecognized
+		return make(map[ToolsetID]bool), unrecognized, allToolsetIDs, defaultToolsetIDList, descriptions
 	}
 
 	enabledToolsets := make(map[ToolsetID]bool, len(expanded))
 	for _, id := range expanded {
 		enabledToolsets[id] = true
 	}
-	return enabledToolsets, unrecognized
-}
-
-// defaultToolsetIDs returns toolset IDs marked as Default in their metadata.
-func (b *Builder) defaultToolsetIDs() []ToolsetID {
-	seen := make(map[ToolsetID]bool)
-	for i := range b.tools {
-		if b.tools[i].Toolset.Default {
-			seen[b.tools[i].Toolset.ID] = true
-		}
-	}
-	for i := range b.resourceTemplates {
-		if b.resourceTemplates[i].Toolset.Default {
-			seen[b.resourceTemplates[i].Toolset.ID] = true
-		}
-	}
-	for i := range b.prompts {
-		if b.prompts[i].Toolset.Default {
-			seen[b.prompts[i].Toolset.ID] = true
-		}
-	}
-
-	ids := make([]ToolsetID, 0, len(seen))
-	for id := range seen {
-		ids = append(ids, id)
-	}
-	return ids
+	return enabledToolsets, unrecognized, allToolsetIDs, defaultToolsetIDList, descriptions
 }

pkg/registry/filters.go

@@ -149,7 +149,7 @@ func (r *Registry) AvailablePrompts(ctx context.Context) []ServerPrompt {
 }
 
 // filterToolsByName returns tools matching the given name, checking deprecated aliases.
-// Returns from the current tools slice (respects existing filter chain).
+// Uses linear scan - optimized for single-lookup per-request scenarios (ForMCPRequest).
 func (r *Registry) filterToolsByName(name string) []ServerTool {
 	// First check for exact match
 	for i := range r.tools {
@@ -169,9 +169,9 @@ func (r *Registry) filterToolsByName(name string) []ServerTool {
 }
 
 // filterResourcesByURI returns resource templates matching the given URI pattern.
+// Uses linear scan - optimized for single-lookup per-request scenarios (ForMCPRequest).
 func (r *Registry) filterResourcesByURI(uri string) []ServerResourceTemplate {
 	for i := range r.resourceTemplates {
-		// Check if URI matches the template pattern (exact match on URITemplate string)
 		if r.resourceTemplates[i].Template.URITemplate == uri {
 			return []ServerResourceTemplate{r.resourceTemplates[i]}
 		}
@@ -180,6 +180,7 @@ func (r *Registry) filterResourcesByURI(uri string) []ServerResourceTemplate {
 }
 
 // filterPromptsByName returns prompts matching the given name.
+// Uses linear scan - optimized for single-lookup per-request scenarios (ForMCPRequest).
 func (r *Registry) filterPromptsByName(name string) []ServerPrompt {
 	for i := range r.prompts {
 		if r.prompts[i].Prompt.Name == name {

pkg/registry/registry.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"slices"
 	"sort"
+	"sync"
 
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
@@ -25,15 +26,24 @@ import (
 //   - Lazy dependency injection during registration via RegisterAll()
 //   - Runtime toolset enabling for dynamic toolsets mode
 type Registry struct {
-	// tools holds all tools in this group
+	// tools holds all tools in this group (ordered for iteration)
 	tools []ServerTool
-	// resourceTemplates holds all resource templates in this group
+	// toolsByName provides O(1) lookup by tool name (lazy-initialized)
+	// Used by FindToolByName for repeated lookups in long-lived servers
+	toolsByName     map[string]*ServerTool
+	toolsByNameOnce sync.Once
+	// resourceTemplates holds all resource templates in this group (ordered for iteration)
 	resourceTemplates []ServerResourceTemplate
-	// prompts holds all prompts in this group
+	// prompts holds all prompts in this group (ordered for iteration)
 	prompts []ServerPrompt
 	// deprecatedAliases maps old tool names to new canonical names
 	deprecatedAliases map[string]string
 
+	// Pre-computed toolset metadata (set during Build)
+	toolsetIDs          []ToolsetID          // sorted list of all toolset IDs
+	defaultToolsetIDs   []ToolsetID          // sorted list of default toolset IDs
+	toolsetDescriptions map[ToolsetID]string // toolset ID -> description
+
 	// Filters - these control what's returned by Available* methods
 	// readOnly when true filters out write tools
 	readOnly bool
@@ -57,6 +67,18 @@ func (r *Registry) UnrecognizedToolsets() []string {
 	return r.unrecognizedToolsets
 }
 
+// getToolsByName returns the toolsByName map, initializing it lazily on first call.
+// Used by FindToolByName for O(1) lookups in long-lived servers with repeated lookups.
+func (r *Registry) getToolsByName() map[string]*ServerTool {
+	r.toolsByNameOnce.Do(func() {
+		r.toolsByName = make(map[string]*ServerTool, len(r.tools))
+		for i := range r.tools {
+			r.toolsByName[r.tools[i].Tool.Name] = &r.tools[i]
+		}
+	})
+	return r.toolsByName
+}
+
 // MCP method constants for use with ForMCPRequest.
 const (
 	MCPMethodInitialize             = "initialize"
@@ -90,6 +112,8 @@ const (
 // All existing filters (read-only, toolsets, etc.) still apply to the returned items.
 func (r *Registry) ForMCPRequest(method string, itemName string) *Registry {
 	// Create a shallow copy with shared filter settings
+	// Note: lazy-init maps (toolsByName, etc.) are NOT copied - the new Registry
+	// will initialize its own maps on first use if needed
 	result := &Registry{
 		tools:                r.tools,
 		resourceTemplates:    r.resourceTemplates,
@@ -142,75 +166,18 @@ func (r *Registry) ForMCPRequest(method string, itemName string) *Registry {
 
 // ToolsetIDs returns a sorted list of unique toolset IDs from all tools in this group.
 func (r *Registry) ToolsetIDs() []ToolsetID {
-	seen := make(map[ToolsetID]bool)
-	for i := range r.tools {
-		seen[r.tools[i].Toolset.ID] = true
-	}
-	for i := range r.resourceTemplates {
-		seen[r.resourceTemplates[i].Toolset.ID] = true
-	}
-	for i := range r.prompts {
-		seen[r.prompts[i].Toolset.ID] = true
-	}
-
-	ids := make([]ToolsetID, 0, len(seen))
-	for id := range seen {
-		ids = append(ids, id)
-	}
-	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
-	return ids
+	return r.toolsetIDs
 }
 
 // DefaultToolsetIDs returns the IDs of toolsets marked as Default in their metadata.
 // The IDs are returned in sorted order for deterministic output.
 func (r *Registry) DefaultToolsetIDs() []ToolsetID {
-	seen := make(map[ToolsetID]bool)
-	for i := range r.tools {
-		if r.tools[i].Toolset.Default {
-			seen[r.tools[i].Toolset.ID] = true
-		}
-	}
-	for i := range r.resourceTemplates {
-		if r.resourceTemplates[i].Toolset.Default {
-			seen[r.resourceTemplates[i].Toolset.ID] = true
-		}
-	}
-	for i := range r.prompts {
-		if r.prompts[i].Toolset.Default {
-			seen[r.prompts[i].Toolset.ID] = true
-		}
-	}
-
-	ids := make([]ToolsetID, 0, len(seen))
-	for id := range seen {
-		ids = append(ids, id)
-	}
-	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
-	return ids
+	return r.defaultToolsetIDs
 }
 
 // ToolsetDescriptions returns a map of toolset ID to description for all toolsets.
 func (r *Registry) ToolsetDescriptions() map[ToolsetID]string {
-	descriptions := make(map[ToolsetID]string)
-	for i := range r.tools {
-		t := &r.tools[i]
-		if t.Toolset.Description != "" {
-			descriptions[t.Toolset.ID] = t.Toolset.Description
-		}
-	}
-	for i := range r.resourceTemplates {
-		res := &r.resourceTemplates[i]
-		if res.Toolset.Description != "" {
-			descriptions[res.Toolset.ID] = res.Toolset.Description
-		}
-	}
-	for i := range r.prompts {
-		p := &r.prompts[i]
-		if p.Toolset.Description != "" {
-			descriptions[p.Toolset.ID] = p.Toolset.Description
-		}
-	}
-	return descriptions
+	return r.toolsetDescriptions
 }
 
 // RegisterTools registers all available tools with the server using the provided dependencies.
@@ -269,11 +236,8 @@ func (r *Registry) ResolveToolAliases(toolNames []string) (resolved []string, al
 // Returns the tool, its toolset ID, and an error if not found.
 // This searches ALL tools regardless of filters.
 func (r *Registry) FindToolByName(toolName string) (*ServerTool, ToolsetID, error) {
-	for i := range r.tools {
-		tool := &r.tools[i]
-		if tool.Tool.Name == toolName {
-			return tool, tool.Toolset.ID, nil
-		}
+	if tool, ok := r.getToolsByName()[toolName]; ok {
+		return tool, tool.Toolset.ID, nil
 	}
 	return nil, "", NewToolDoesNotExistError(toolName)
 }