refactor: consolidate toolset validation into ToolsetGroup

- Add Default field to ToolsetMetadata and derive defaults from metadata
- Move toolset validation into WithToolsets (trims whitespace, dedupes, tracks unrecognized)
- Add UnrecognizedToolsets() method for warning about typos
- Add DefaultToolsetIDs() method to derive defaults from metadata
- Remove redundant functions: CleanToolsets, GetValidToolsetIDs, AvailableToolsets, GetDefaultToolsetIDs
- Update DynamicTools to take ToolsetGroup for schema enum generation
- Add stubTranslator for cases needing ToolsetGroup without translations

This eliminates hardcoded toolset lists - everything is now derived from
the actual registered tools and their metadata.

Author: SamMorrowDrums

e2e/e2e_test.go

@@ -178,7 +178,7 @@ func setupMCPClient(t *testing.T, options ...clientOption) *mcp.ClientSession {
 		// so that there is a shared setup mechanism, but let's wait till we feel more friction.
 		enabledToolsets := opts.enabledToolsets
 		if enabledToolsets == nil {
-			enabledToolsets = github.GetDefaultToolsetIDs()
+			enabledToolsets = github.NewToolsetGroup(translations.NullTranslationHelper).DefaultToolsetIDs()
 		}
 
 		ghServer, err := ghmcp.NewMCPServer(ghmcp.MCPServerConfig{

internal/ghmcp/server.go

@@ -109,12 +109,7 @@ func NewMCPServer(cfg MCPServerConfig) (*mcp.Server, error) {
 	// - explicit list means "use these toolsets"
 	var enabledToolsets []string
 	if cfg.EnabledToolsets != nil {
-		// Clean up explicitly passed toolsets (removes duplicates, whitespace)
-		var invalidToolsets []string
-		enabledToolsets, invalidToolsets = github.CleanToolsets(cfg.EnabledToolsets)
-		if len(invalidToolsets) > 0 {
-			fmt.Fprintf(os.Stderr, "Invalid toolsets ignored: %s\n", strings.Join(invalidToolsets, ", "))
-		}
+		enabledToolsets = cfg.EnabledToolsets
 	} else if cfg.DynamicToolsets {
 		// Dynamic mode with no toolsets specified: start with no toolsets enabled
 		// so users can enable them on demand via the dynamic tools
@@ -181,6 +176,11 @@ func NewMCPServer(cfg MCPServerConfig) (*mcp.Server, error) {
 		WithTools(enabledTools).
 		WithFeatureChecker(createFeatureChecker(cfg.EnabledFeatures))
 
+	// Warn about unrecognized toolset names (likely typos)
+	if unrecognized := filteredTsg.UnrecognizedToolsets(); len(unrecognized) > 0 {
+		fmt.Fprintf(os.Stderr, "Warning: unrecognized toolsets ignored: %s\n", strings.Join(unrecognized, ", "))
+	}
+
 	// Register all mcp functionality with the server
 	// Use background context for local server (no per-request actor context)
 	filteredTsg.RegisterAll(context.Background(), ghServer, deps)
@@ -196,7 +196,7 @@ func NewMCPServer(cfg MCPServerConfig) (*mcp.Server, error) {
 			ToolDeps:     deps,
 			T:            cfg.Translator,
 		}
-		dynamicTools := github.DynamicTools()
+		dynamicTools := github.DynamicTools(filteredTsg)
 		for _, tool := range dynamicTools {
 			tool.RegisterFunc(ghServer, dynamicDeps)
 		}

pkg/github/dynamic_tools.go

@@ -33,20 +33,9 @@ func NewDynamicTool(toolset toolsets.ToolsetMetadata, tool mcp.Tool, handler fun
 	})
 }
 
-// AllToolsetIDsEnum returns all available toolset IDs as an enum for JSON Schema.
-func AllToolsetIDsEnum() []any {
-	toolsets := AvailableToolsets()
-	result := make([]any, len(toolsets))
-	for i, ts := range toolsets {
-		result[i] = ts.ID
-	}
-	return result
-}
-
-// ToolsetEnum returns the list of toolset IDs as an enum for JSON Schema.
-// Deprecated: Use AllToolsetIDsEnum() instead.
-func ToolsetEnum(toolsetGroup *toolsets.ToolsetGroup) []any {
-	toolsetIDs := toolsetGroup.ToolsetIDs()
+// toolsetIDsEnum returns the list of toolset IDs as an enum for JSON Schema.
+func toolsetIDsEnum(tsg *toolsets.ToolsetGroup) []any {
+	toolsetIDs := tsg.ToolsetIDs()
 	result := make([]any, len(toolsetIDs))
 	for i, id := range toolsetIDs {
 		result[i] = id
@@ -56,16 +45,17 @@ func ToolsetEnum(toolsetGroup *toolsets.ToolsetGroup) []any {
 
 // DynamicTools returns the tools for dynamic toolset management.
 // These tools allow runtime discovery and enablement of toolsets.
-func DynamicTools() []toolsets.ServerTool {
+// The tsg parameter provides the available toolset IDs for JSON Schema enums.
+func DynamicTools(tsg *toolsets.ToolsetGroup) []toolsets.ServerTool {
 	return []toolsets.ServerTool{
 		ListAvailableToolsets(),
-		GetToolsetsTools(),
-		EnableToolset(),
+		GetToolsetsTools(tsg),
+		EnableToolset(tsg),
 	}
 }
 
 // EnableToolset creates a tool that enables a toolset at runtime.
-func EnableToolset() toolsets.ServerTool {
+func EnableToolset(tsg *toolsets.ToolsetGroup) toolsets.ServerTool {
 	return NewDynamicTool(
 		ToolsetMetadataDynamic,
 		mcp.Tool{
@@ -81,7 +71,7 @@ func EnableToolset() toolsets.ServerTool {
 					"toolset": {
 						Type:        "string",
 						Description: "The name of the toolset to enable",
-						Enum:        AllToolsetIDsEnum(),
+						Enum:        toolsetIDsEnum(tsg),
 					},
 				},
 				Required: []string{"toolset"},
@@ -163,7 +153,7 @@ func ListAvailableToolsets() toolsets.ServerTool {
 }
 
 // GetToolsetsTools creates a tool that lists all tools in a specific toolset.
-func GetToolsetsTools() toolsets.ServerTool {
+func GetToolsetsTools(tsg *toolsets.ToolsetGroup) toolsets.ServerTool {
 	return NewDynamicTool(
 		ToolsetMetadataDynamic,
 		mcp.Tool{
@@ -179,7 +169,7 @@ func GetToolsetsTools() toolsets.ServerTool {
 					"toolset": {
 						Type:        "string",
 						Description: "The name of the toolset you want to get the tools for",
-						Enum:        AllToolsetIDsEnum(),
+						Enum:        toolsetIDsEnum(tsg),
 					},
 				},
 				Required: []string{"toolset"},

pkg/github/tools.go

@@ -28,10 +28,12 @@ var (
 	ToolsetMetadataContext = toolsets.ToolsetMetadata{
 		ID:          "context",
 		Description: "Tools that provide context about the current user and GitHub context you are operating in",
+		Default:     true,
 	}
 	ToolsetMetadataRepos = toolsets.ToolsetMetadata{
 		ID:          "repos",
 		Description: "GitHub Repository related tools",
+		Default:     true,
 	}
 	ToolsetMetadataGit = toolsets.ToolsetMetadata{
 		ID:          "git",
@@ -40,14 +42,17 @@ var (
 	ToolsetMetadataIssues = toolsets.ToolsetMetadata{
 		ID:          "issues",
 		Description: "GitHub Issues related tools",
+		Default:     true,
 	}
 	ToolsetMetadataPullRequests = toolsets.ToolsetMetadata{
 		ID:          "pull_requests",
 		Description: "GitHub Pull Request related tools",
+		Default:     true,
 	}
 	ToolsetMetadataUsers = toolsets.ToolsetMetadata{
 		ID:          "users",
 		Description: "GitHub User related tools",
+		Default:     true,
 	}
 	ToolsetMetadataOrgs = toolsets.ToolsetMetadata{
 		ID:          "orgs",
@@ -107,53 +112,6 @@ var (
 	}
 )
 
-func AvailableToolsets() []toolsets.ToolsetMetadata {
-	return []toolsets.ToolsetMetadata{
-		ToolsetMetadataContext,
-		ToolsetMetadataRepos,
-		ToolsetMetadataGit,
-		ToolsetMetadataIssues,
-		ToolsetMetadataPullRequests,
-		ToolsetMetadataUsers,
-		ToolsetMetadataOrgs,
-		ToolsetMetadataActions,
-		ToolsetMetadataCodeSecurity,
-		ToolsetMetadataSecretProtection,
-		ToolsetMetadataDependabot,
-		ToolsetMetadataNotifications,
-		ToolsetMetadataExperiments,
-		ToolsetMetadataDiscussions,
-		ToolsetMetadataGists,
-		ToolsetMetadataSecurityAdvisories,
-		ToolsetMetadataProjects,
-		ToolsetMetadataStargazers,
-		ToolsetMetadataDynamic,
-		ToolsetLabels,
-	}
-}
-
-// GetValidToolsetIDs returns a map of all valid toolset IDs for quick lookup
-func GetValidToolsetIDs() map[toolsets.ToolsetID]bool {
-	validIDs := make(map[toolsets.ToolsetID]bool)
-	for _, toolset := range AvailableToolsets() {
-		validIDs[toolset.ID] = true
-	}
-	// Add special keywords
-	validIDs[ToolsetMetadataAll.ID] = true
-	validIDs[ToolsetMetadataDefault.ID] = true
-	return validIDs
-}
-
-func GetDefaultToolsetIDs() []toolsets.ToolsetID {
-	return []toolsets.ToolsetID{
-		ToolsetMetadataContext.ID,
-		ToolsetMetadataRepos.ID,
-		ToolsetMetadataIssues.ID,
-		ToolsetMetadataPullRequests.ID,
-		ToolsetMetadataUsers.ID,
-	}
-}
-
 // AllTools returns all tools with their embedded toolset metadata.
 // Tool functions return ServerTool directly with toolset info.
 func AllTools(t translations.TranslationHelperFunc) []toolsets.ServerTool {
@@ -304,16 +262,19 @@ func ToStringPtr(s string) *string {
 
 // GenerateToolsetsHelp generates the help text for the toolsets flag
 func GenerateToolsetsHelp() string {
-	// Format default tools
-	defaultIDs := GetDefaultToolsetIDs()
+	// Get toolset group to derive defaults and available toolsets
+	tsg := NewToolsetGroup(stubTranslator)
+
+	// Format default tools from metadata
+	defaultIDs := tsg.DefaultToolsetIDs()
 	defaultStrings := make([]string, len(defaultIDs))
 	for i, id := range defaultIDs {
 		defaultStrings[i] = string(id)
 	}
 	defaultTools := strings.Join(defaultStrings, ", ")
 
-	// Format available tools with line breaks for better readability
-	allToolsets := AvailableToolsets()
+	// Get all available toolsets (excludes context and dynamic for display)
+	allToolsets := tsg.AvailableToolsets("context", "dynamic")
 	var availableToolsLines []string
 	const maxLineLength = 70
 	currentLine := ""
@@ -349,6 +310,10 @@ func GenerateToolsetsHelp() string {
 	return toolsetsHelp
 }
 
+// stubTranslator is a passthrough translator for cases where we need a ToolsetGroup
+// but don't need actual translations (e.g., getting toolset IDs for CLI help).
+func stubTranslator(_, fallback string) string { return fallback }
+
 // AddDefaultToolset removes the default toolset and expands it to the actual default toolset IDs
 func AddDefaultToolset(result []string) []string {
 	hasDefault := false
@@ -367,43 +332,16 @@ func AddDefaultToolset(result []string) []string {
 
 	result = RemoveToolset(result, string(ToolsetMetadataDefault.ID))
 
-	for _, defaultToolset := range GetDefaultToolsetIDs() {
-		if !seen[string(defaultToolset)] {
-			result = append(result, string(defaultToolset))
+	// Get default toolset IDs from the ToolsetGroup
+	tsg := NewToolsetGroup(stubTranslator)
+	for _, id := range tsg.DefaultToolsetIDs() {
+		if !seen[string(id)] {
+			result = append(result, string(id))
 		}
 	}
 	return result
 }
 
-// cleanToolsets cleans and handles special toolset keywords:
-// - Duplicates are removed from the result
-// - Removes whitespaces
-// - Validates toolset names and returns invalid ones separately - for warning reporting
-// Returns: (toolsets, invalidToolsets)
-func CleanToolsets(enabledToolsets []string) ([]string, []string) {
-	seen := make(map[string]bool)
-	result := make([]string, 0, len(enabledToolsets))
-	invalid := make([]string, 0)
-	validIDs := GetValidToolsetIDs()
-
-	// Add non-default toolsets, removing duplicates and trimming whitespace
-	for _, toolset := range enabledToolsets {
-		trimmed := strings.TrimSpace(toolset)
-		if trimmed == "" {
-			continue
-		}
-		if !seen[trimmed] {
-			seen[trimmed] = true
-			result = append(result, trimmed)
-			if !validIDs[toolsets.ToolsetID(trimmed)] {
-				invalid = append(invalid, trimmed)
-			}
-		}
-	}
-
-	return result, invalid
-}
-
 func RemoveToolset(tools []string, toRemove string) []string {
 	result := make([]string, 0, len(tools))
 	for _, tool := range tools {