add logic to register specific tools

Author: tommaso-moro

pkg/github/tools.go

@@ -516,3 +516,30 @@ func ContainsToolset(tools []string, toCheck string) bool {
 	}
 	return false
 }
+
+// CleanTools validates and cleans tool names:
+// - Duplicates are removed from the result
+// - Removes whitespaces
+// - Validation of tool existence is done during registration
+// Returns: (cleaned tools, invalid tools)
+// Note: Invalid tools are identified during registration, so this function only cleans and deduplicates.
+func CleanTools(toolNames []string) ([]string, []string) {
+	seen := make(map[string]bool)
+	result := make([]string, 0, len(toolNames))
+	invalid := make([]string, 0)
+
+	// Remove duplicates and trim whitespace
+	for _, tool := range toolNames {
+		trimmed := strings.TrimSpace(tool)
+		if trimmed == "" {
+			continue
+		}
+		if !seen[trimmed] {
+			seen[trimmed] = true
+			result = append(result, trimmed)
+		}
+	}
+
+	// Validation will happen during registration, so we return empty invalid list here
+	return result, invalid
+}

pkg/toolsets/toolsets.go

@@ -263,3 +263,62 @@ func (tg *ToolsetGroup) GetToolset(name string) (*Toolset, error) {
 	}
 	return toolset, nil
 }
+
+type ToolDoesNotExistError struct {
+	Name string
+}
+
+func (e *ToolDoesNotExistError) Error() string {
+	return fmt.Sprintf("tool %s does not exist", e.Name)
+}
+
+func NewToolDoesNotExistError(name string) *ToolDoesNotExistError {
+	return &ToolDoesNotExistError{Name: name}
+}
+
+// FindToolByName searches all toolsets (enabled or disabled) for a tool by name.
+// Returns the tool, its parent toolset name, and an error if not found.
+func (tg *ToolsetGroup) FindToolByName(toolName string) (*server.ServerTool, string, error) {
+	for toolsetName, toolset := range tg.Toolsets {
+		// Check read tools
+		for _, tool := range toolset.readTools {
+			if tool.Tool.Name == toolName {
+				return &tool, toolsetName, nil
+			}
+		}
+		// Check write tools
+		for _, tool := range toolset.writeTools {
+			if tool.Tool.Name == toolName {
+				return &tool, toolsetName, nil
+			}
+		}
+	}
+	return nil, "", NewToolDoesNotExistError(toolName)
+}
+
+// RegisterSpecificTools registers only the specified tools, bypassing toolset enablement.
+// Respects read-only mode (skips write tools if readOnly=true).
+// Returns error if any tool is not found.
+func (tg *ToolsetGroup) RegisterSpecificTools(s *server.MCPServer, toolNames []string, readOnly bool) error {
+	for _, toolName := range toolNames {
+		tool, toolsetName, err := tg.FindToolByName(toolName)
+		if err != nil {
+			return fmt.Errorf("tool %s not found: %w", toolName, err)
+		}
+
+		// Check if it's a write tool and we're in read-only mode
+		// ReadOnlyHint should always be set, but add defensive check
+		if tool.Tool.Annotations.ReadOnlyHint != nil {
+			isWriteTool := !*tool.Tool.Annotations.ReadOnlyHint
+			if isWriteTool && readOnly {
+				// Skip write tools in read-only mode
+				continue
+			}
+		}
+
+		// Register the tool
+		s.AddTool(tool.Tool, tool.Handler)
+		_ = toolsetName // toolsetName is available for potential future use (logging, etc.)
+	}
+	return nil
+}