I have a custom ContentType that is supposed to support uploading images and embeddables, but the Rich Text Editor is not showing the option

When I load my rich text editor (from within an Admin Panel)  I don't see any embeddables.  And when I try to add an image, I don't see the "upload" link.  Any Ideas?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Telligent.Evolution.Extensibility;
using Telligent.Evolution.Extensibility.Api.Version1;
using Telligent.Evolution.Extensibility.Content.Version1;
using Telligent.Evolution.Extensibility.EmbeddableContent.Version2;
using Telligent.Evolution.Extensibility.Storage.Version1;

namespace HearingFirst.Learning.Content
{
    public class RequirementContentType : IContentType, IContentEmbeddableContentType, IFileEmbeddableContentType
    {
        private IFileEmbeddableContentTypeController _embeddedFileController;
        private IContentEmbeddableContentTypeController _embeddedController;
        IContentStateChanges _contentState;

        #region IPLugin
        public string Name => "Hearing First Learning - Requirement Content Type";

        public string Description => "The content type definition for requirements";
        public void Initialize()
        {
            // Embeds
            Events.RequirementEvents.Events.OnBeforeRequirementUpdated += RequirementBeforeUpdate;
            Events.RequirementEvents.Events.OnBeforeRequirementCreated += RequirementBeforeCreate;

            // Auditing
            Events.RequirementEvents.Events.OnBeforeRequirementUpdated += AuditRequirementUpdate;
            Events.CourseRegistrationEvents.Events.OnBeforeCourseRegistrationUpdated += AuditRegistrationUpdated;
        }
        #endregion
        #region ICOntentType
        public string ContentTypeName => "Course Requirement";

        public Guid ContentTypeId => Components.Requirements.CONTENT_TYPE_ID;

        public Guid[] ApplicationTypes =>  new Guid[] { Apis.Get<IGroups>().ApplicationTypeId };


        public void AttachChangeEvents(IContentStateChanges stateChanges)
        {
            _contentState = stateChanges;
        }

        public IContent Get(Guid contentId)
        {
            return Components.Requirements.Get(contentId);
        }
        #endregion
        #region IContentEmbeddableContentTypeController Members
        public void SetController(IContentEmbeddableContentTypeController controller)
        {
            _embeddedController = controller;
        }
        #endregion
        #region  IFileEmbeddableContentType Members
        public void SetController(IFileEmbeddableContentTypeController controller)
        {
            _embeddedFileController = controller;
        }

        public bool CanAddFiles(int userId)
        {
            return true;
        }
        #endregion
        #region Event Handlers
        private void RequirementBeforeUpdate(Events.RequirementEventArgs e) {
            if (_embeddedFileController == null || _embeddedController == null)
            {
                return;
            }

            if (_embeddedController != null)
            {
                _embeddedController.Updated(e.Requirement.ContentId, null, (updater) =>
                {
                    e.Requirement.Body = updater.Update(e.Requirement.Body);

                });
            }

            var hasPermission = true;
            var targetFileStore = CentralizedFileStorage.GetFileStore(Plugins.CourseFileStorage.FILE_STORAGE_KEY);

            e.Requirement.Body = _embeddedFileController.SaveFilesInHtml(e.Requirement.Body, f =>
            {
                if (!hasPermission)
                {
                    _embeddedFileController.InvalidFile(f, "You do not have permission to add files to a course.");
                }

                if (f.FileStoreKey.Contains("hfle23"))
                {
                    return targetFileStore.GetFile(f.Path, f.FileName);
                }

                using (var stream = f.OpenReadStream())
                {
                    var targetFile = targetFileStore.AddFile(e.Requirement.Id.ToString("N"), String.Format("{0}_{1}", e.Requirement.Id.ToString(), f.FileName), stream, true);
                    if (targetFile != null)
                    {
                        return targetFile;
                    }
                    else
                    {
                        _embeddedFileController.InvalidFile(f, "An error occurred while saving an embedded file to the session.");
                    }
                }

                return null;
            });

        }
        private void RequirementBeforeCreate(Events.RequirementEventArgs e)
        {
            if (_embeddedFileController == null || _embeddedController == null)
            {
                return;
            }

            if (_embeddedController != null)
            {
                _embeddedController.Updated(e.Requirement.ContentId, null, (updater) =>
                {
                    e.Requirement.Body = updater.Update(e.Requirement.Body);

                });
            }

            var hasPermission = true;
            var targetFileStore = CentralizedFileStorage.GetFileStore(Plugins.CourseFileStorage.FILE_STORAGE_KEY);

            e.Requirement.Body = _embeddedFileController.SaveFilesInHtml(e.Requirement.Body, f =>
            {
                if (!hasPermission)
                {
                    _embeddedFileController.InvalidFile(f, "You do not have permission to add files to a course.");
                }

                if (f.FileStoreKey.Contains("hfle23"))
                {
                    return targetFileStore.GetFile(f.Path, f.FileName);
                }

                using (var stream = f.OpenReadStream())
                {
                    var targetFile = targetFileStore.AddFile(e.Requirement.Id.ToString("N"), String.Format("{0}_{1}", e.Requirement.Id.ToString(), f.FileName), stream, true);
                    if (targetFile != null)
                    {
                        return targetFile;
                    }
                    else
                    {
                        _embeddedFileController.InvalidFile(f, "An error occurred while saving an embedded file to the session.");
                    }
                }

                return null;
            });
        }
        private void AuditRequirementUpdate(Events.RequirementEventArgs e)
        {
            var _auditing = Apis.Get<IAuditing>();
            var requirement = Components.Requirements.Get(e.Requirement.Id);
            _auditing.Edited(requirement, e.Requirement);
        }
        private void AuditRegistrationUpdated(Events.CourseRegistrationEventArgs e)
        {
            var _auditing = Apis.Get<IAuditing>();
            var registration = Components.Registrations.Get(e.CourseRegistration.Id);
            _auditing.Edited(registration, e.CourseRegistration);
        }
        #endregion
    }
}