Abstracted email sender with content providers
public EmailMessage()
{
    ToAddresses = new List&lt;EmailAddress&gt;();
    CcAddresses = new List&lt;EmailAddress&gt;();
}

Not necessary, I can understand if you just initiate the ToAddress, however, initiating the lists like this might consume a lot of memory (imagine you have large amount of EmailMessage instances! So, I would suggest to keep them as null, and use null validation to force initiating them when it's needed (like in sender).
your overall design is good enough, however, you could do this directly :
public class EmailMessage 
{
    public EmailAddress From { get; set; }
    public IEnumerable&lt;EmailAddress&gt; To { get; set; }
    public IEnumerable&lt;EmailAddress&gt; Cc { get; set; }
    public IEnumerable&lt;EmailAddress&gt; Bcc { get; set; }
    public string Subject { get; set; }
    public string Body { get; set; }
}

public interface IEmailProvider
{
    IEmailServerSetting ServerSettings { get; set; }
}

EmailMessage should contain From(required), To(required), CC(optional),BCC(optional), Subject, and Body as a full model of the message. The reason behind that is that it will be always paired together as requirement to any message, later on, it would be also easier to implement on the database side. using IEnumerable&lt;EmailAddress&gt; would open to use any collection that implements IEnumerable. So, it's not restricted to List.
For IEmailProvider As an email provider should also contain its own settings as requirement. This would make things easier for you, to have each email message with it's own settings. This way, you can send multiple emails from different providers with no extra coding. IOptions is treated independently, but in reality, IOptions won't be useful by itself, and it would only used by EmailProvider, so if we add it to the contract, it'll always be implemented with the interface, this way you forced the provider to always have IOptions. Besides, IOptions should be renamed to something like EmailServerSetting or EmailProviderSetting to relate it to the main implementation. As these are settings and not options. Use IOptions to handle the email optional settings and features that can be managed like sending as text or html, disable/enable attachments, pictures ..etc.
Also, you need a middle-ware class to wrap things up, and uses SmtpClient. This would give you the advantage of increasing the flexibility of your current work and wrap them under one roof along with ease things up for reusing code (such as MimeMessage, TextPart ..etc.) instead of reimplement it on each new sender. It also would give you the ability to create a collection to store multiple providers if you're going that far. also, you will be able to add new providers, handle them, handle messages, and keep your work scoped.
Here is how I imagine the final usage :
Creating a new provider :
// creating a new email provider 
    public class SomeEmailProvider : IEmailProvider
    {
        // only set the settings internally but it's exposed to be readonly
        public EmailServerSetting ServerSettings { get; private set; }
        
        public SomeEmailProvider()
        {
            //set up the server settings
            ServerSettings = new EmailServerSetting 
            {
                ServerType = EmailServerType.POP, 
                Server = &quot;pop.mail.com&quot;,
                Port = 995, 
                Encryption = EmailServerEncryption.SSLOrTLS, 
                EnableSsl = true
            };      
        }
       // some other related code 
    }

now, creating a new mail message and sending it :
// can be single object or collection 
var messages = new EmailMessage
{
    From = new EmailAddress(&quot;Test&quot;, &quot;test@mail.com&quot;), 
    To = new EmailAddress [] {
         new EmailAddress(&quot;Test1&quot;, &quot;test1@mail.com&quot;), 
         new EmailAddress(&quot;Test2&quot;, &quot;test2@mail.com&quot;)
        }, 
    Subject = &quot;Testing Subject&quot;, 
    Body = &quot;Normal Text Body&quot;           
};

using(var client = new EmailClient(new SomeEmailProvider()))
{
    client.Options = new EmailClientOptions 
    {
        // would send it as plain text 
        EnableHtml = false 
    };
    
    client.Messages.Add(messages); 
    
    client.Send();  
}