diff --git a/DisCatSharp.Configuration/ConfigurationExtensions.cs b/DisCatSharp.Configuration/ConfigurationExtensions.cs
index 3c836ea2f..c7ece00b6 100644
--- a/DisCatSharp.Configuration/ConfigurationExtensions.cs
+++ b/DisCatSharp.Configuration/ConfigurationExtensions.cs
@@ -1,279 +1,287 @@
 // This file is part of the DisCatSharp project, a fork of DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections;
 using System.Linq;
 using DisCatSharp.Configuration.Models;
 using Microsoft.Extensions.Configuration;
 
 namespace DisCatSharp.Configuration
 {
     /// <summary>
     /// The configuration extensions.
     /// </summary>
     internal static class ConfigurationExtensions
     {
         /// <summary>
         /// The factory error message.
         /// </summary>
         private const string FactoryErrorMessage = "Require a function which provides a default entity to work with";
         /// <summary>
         /// The default root lib.
         /// </summary>
         public const string DefaultRootLib = "DisCatSharp";
         /// <summary>
         /// The config suffix.
         /// </summary>
         private const string ConfigSuffix = "Configuration";
 
 
         /// <summary>
         /// Easily piece together paths that will work within <see cref="IConfiguration"/>
         /// </summary>
         /// <param name="config">(not used - only for adding context based functionality)</param>
         /// <param name="values">The strings to piece together</param>
         /// <returns>Strings joined together via ':'</returns>
         public static string ConfigPath(this IConfiguration config, params string[] values) => string.Join(":", values);
 
         /// <summary>
         /// Skims over the configuration section and only overrides values that are explicitly defined within the config
         /// </summary>
         /// <param name="config">Instance of config</param>
         /// <param name="section">Section which contains values for <paramref name="config"/></param>
         private static void HydrateInstance(ref object config, ConfigSection section)
         {
             var props = config.GetType().GetProperties();
 
             foreach (var prop in props)
             {
                 // Must have a set method for this to work, otherwise continue on
                 if (prop.SetMethod == null)
                     continue;
 
                 var entry = section.GetValue(prop.Name);
                 object? value = null;
 
                 if (typeof(string) == prop.PropertyType)
                 {
                     // We do NOT want to override value if nothing was provided
                     if(!string.IsNullOrEmpty(entry))
                         prop.SetValue(config, entry);
 
                     continue;
                 }
 
                 // We need to address collections a bit differently
                 // They can come in the form of    "root:section:name" with a string representation OR
                 // "root:section:name:0"  <--- this is not detectable when checking the above path
                 if (typeof(IEnumerable).IsAssignableFrom(prop.PropertyType))
                 {
                     value = string.IsNullOrEmpty(section.GetValue(prop.Name))
                         ? section.Config
                             .GetSection(section.GetPath(prop.Name)).Get(prop.PropertyType)
                         : Newtonsoft.Json.JsonConvert.DeserializeObject(entry, prop.PropertyType);
 
                     if (value == null)
                         continue;
 
                     prop.SetValue(config, value);
                 }
 
                 // From this point onward we require the 'entry' value to have something useful
                 if (string.IsNullOrEmpty(entry))
                     continue;
 
                 try
                 {
                     // Primitive types are simple to convert
                     if (prop.PropertyType.IsPrimitive)
                         value = Convert.ChangeType(entry, prop.PropertyType);
                     else
                     {
                         // The following types require a different approach
                         if (prop.PropertyType.IsEnum)
                             value = Enum.Parse(prop.PropertyType, entry);
                         else if (typeof(TimeSpan) == prop.PropertyType)
                             value = TimeSpan.Parse(entry);
                         else if (typeof(DateTime) == prop.PropertyType)
                             value = DateTime.Parse(entry);
                         else if (typeof(DateTimeOffset) == prop.PropertyType)
                             value = DateTimeOffset.Parse(entry);
                     }
 
                     // Update value within our config instance
                     prop.SetValue(config, value);
                 }
                 catch (Exception ex)
                 {
                     Console.Error.WriteLine(
                         $"Unable to convert value of '{entry}' to type '{prop.PropertyType.Name}' for prop '{prop.Name}' in config '{config.GetType().Name}'\n\t\t{ex.Message}");
                 }
             }
         }
 
         /// <summary>
         /// Instantiate an entity using <paramref name="factory"/> then walk through the specified <paramref name="section"/>
         /// and translate user-defined config values to the instantiated instance from <paramref name="factory"/>
         /// </summary>
         /// <param name="section">Section containing values for targeted config</param>
         /// <param name="factory">Function which generates a default entity</param>
         /// <returns>Hydrated instance of an entity which contains user-defined values (if any)</returns>
         /// <exception cref="ArgumentNullException">When <paramref name="factory"/> is null</exception>
         public static object ExtractConfig(this ConfigSection section, Func<object> factory)
         {
             if (factory == null)
                 throw new ArgumentNullException(nameof(factory),FactoryErrorMessage);
 
             // Create default instance
             var config = factory();
 
             HydrateInstance(ref config, section);
 
             return config;
         }
 
         /// <summary>
         /// Instantiate an entity using <paramref name="factory"/> then walk through the specified <paramref name="sectionName"/>
         /// in <paramref name="config"/>. Translate user-defined config values to the instantiated instance from <paramref name="factory"/>
         /// </summary>
         /// <param name="config">Loaded App Configuration</param>
         /// <param name="sectionName">Name of section to load</param>
         /// <param name="factory">Function which creates a default entity to work with</param>
         /// <param name="rootSectionName">(Optional) Used when section is nested within another. Default value is <see cref="DefaultRootLib"/></param>
         /// <returns>Hydrated instance of an entity which contains user-defined values (if any)</returns>
         /// <exception cref="ArgumentNullException">When <paramref name="factory"/> is null</exception>
         public static object ExtractConfig(this IConfiguration config, string sectionName, Func<object> factory,
             string? rootSectionName = DefaultRootLib)
         {
             if (factory == null)
                 throw new ArgumentNullException(nameof(factory), FactoryErrorMessage);
 
             // create default instance
             var instance = factory();
 
             HydrateInstance(ref instance, new ConfigSection(ref config, sectionName, rootSectionName));
 
             return instance;
         }
 
         /// <summary>
         /// Instantiate a new instance of <typeparamref name="TConfig"/>, then walk through the specified <paramref name="sectionName"/>
         /// in <paramref name="config"/>. Translate user-defined config values to the <typeparamref name="TConfig"/> instance.
         /// </summary>
         /// <param name="config">Loaded App Configuration</param>
         /// <param name="sectionName">Name of section to load</param>
         /// <param name="rootSectionName">(Optional) Used when section is nested with another. Default value is <see cref="DefaultRootLib"/></param>
         /// <typeparam name="TConfig">Type of instance that <paramref name="sectionName"/> represents</typeparam>
         /// <returns>Hydrated instance of <typeparamref name="TConfig"/> which contains the user-defined values (if any).</returns>
         public static TConfig ExtractConfig<TConfig>(this IConfiguration config, string sectionName, string? rootSectionName = DefaultRootLib)
             where TConfig : new()
         {
             // Default values should hopefully be provided from the constructor
             object configInstance = new TConfig();
 
             HydrateInstance(ref configInstance, new ConfigSection(ref config, sectionName, rootSectionName));
 
             return (TConfig) configInstance;
         }
 
         /// <summary>
         /// Determines if <paramref name="config"/> contains a particular section/object (not value)
         /// </summary>
         /// <remarks>
         /// <code>
         /// {
         ///    "Discord": {  // this is a section/object
         ///
         ///    },
         ///    "Value": "something" // this is not a section/object
         /// }
         /// </code>
         /// </remarks>
         /// <param name="config"></param>
         /// <param name="values"></param>
         /// <returns>True if section exists, otherwise false</returns>
         public static bool HasSection(this IConfiguration config, params string[] values)
         {
             if (!values.Any())
                 return false;
 
             if (values.Length == 1)
                 return config.GetChildren().Any(x => x.Key == values[0]);
 
             if (config.GetChildren().All(x => x.Key != values[0]))
                 return false;
 
             var current = config.GetSection(values[0]);
 
             for (var i = 1; i < values.Length - 1; i++)
             {
                 if (current.GetChildren().All(x => x.Key != values[i]))
                     return false;
 
                 current = current.GetSection(values[i]);
             }
 
             return current.GetChildren().Any(x=>x.Key == values[^1]);
         }
 
         /// <summary>
         /// Instantiates an instance of <see cref="DiscordClient"/>, then consumes any custom
         /// configuration from user/developer from <paramref name="config"/>. <br/>
         /// View remarks for more info
         /// </summary>
         /// <remarks>
         /// This is an example of how your JSON structure should look if you wish
         /// to override one or more of the default values from <see cref="DiscordConfiguration"/>
         /// <code>
         /// {
         ///   "DisCatSharp": {
         ///      "Discord": { }
         ///   }
         /// }
         /// </code>
         /// <br/>
         /// Alternatively, you can use the type name itself
         /// <code>
         /// {
         ///   "DisCatSharp": {
         ///      "DiscordConfiguration": { }
         ///   }
         /// }
         /// </code>
+        /// <code>
+        /// {
+        ///   "botSectionName": {
+        ///      "DiscordConfiguration": { }
+        ///   }
+        /// }
+        /// </code>
         /// </remarks>
         /// <param name="config"></param>
+        /// <param name="botSectionName"></param>
         /// <returns>Instance of <see cref="DiscordClient"/></returns>
-        public static DiscordClient BuildClient(this IConfiguration config)
+        public static DiscordClient BuildClient(this IConfiguration config, string botSectionName = DefaultRootLib)
         {
-            var section = config.HasSection(DefaultRootLib, "Discord")
+            var section = config.HasSection(botSectionName, "Discord")
                 ? "Discord"
-                : config.HasSection(DefaultRootLib, $"Discord{ConfigSuffix}")
+                : config.HasSection(botSectionName, $"Discord{ConfigSuffix}")
                     ? $"Discord:{ConfigSuffix}"
                     : null;
 
             return string.IsNullOrEmpty(section)
                 ? new DiscordClient(new())
-                : new DiscordClient(config.ExtractConfig<DiscordConfiguration>(section));
+                : new DiscordClient(config.ExtractConfig<DiscordConfiguration>(section, botSectionName));
         }
     }
 }
diff --git a/DisCatSharp.Hosting.Tests/DisCatSharp.Hosting.Tests.csproj b/DisCatSharp.Hosting.Tests/DisCatSharp.Hosting.Tests.csproj
index 0b717fab1..e529ad0bd 100644
--- a/DisCatSharp.Hosting.Tests/DisCatSharp.Hosting.Tests.csproj
+++ b/DisCatSharp.Hosting.Tests/DisCatSharp.Hosting.Tests.csproj
@@ -1,39 +1,45 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <TargetFramework>net5.0</TargetFramework>
         <Nullable>enable</Nullable>
 
         <IsPackable>false</IsPackable>
         <GenerateDocumentationFile>false</GenerateDocumentationFile>
     </PropertyGroup>
 
     <ItemGroup>
         <PackageReference Include="Microsoft.Extensions.Configuration" Version="5.0.0" />
         <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="5.0.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
         <PackageReference Include="xunit" Version="2.4.1" />
         <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
             <PrivateAssets>all</PrivateAssets>
         </PackageReference>
         <PackageReference Include="coverlet.collector" Version="3.1.0">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
             <PrivateAssets>all</PrivateAssets>
         </PackageReference>
     </ItemGroup>
 
     <ItemGroup>
       <ProjectReference Include="..\DisCatSharp.Hosting\DisCatSharp.Hosting.csproj" />
       <ProjectReference Include="..\DisCatSharp.Interactivity\DisCatSharp.Interactivity.csproj" />
       <ProjectReference Include="..\DisCatSharp.Lavalink\DisCatSharp.Lavalink.csproj" />
       <ProjectReference Include="..\DisCatSharp\DisCatSharp.csproj" />
     </ItemGroup>
 
     <ItemGroup>
       <None Update="interactivity-lavalink.json">
         <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       </None>
+      <None Update="interactivity-different-section.json">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Update="lavalink-different-section.json">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
     </ItemGroup>
 
 </Project>
diff --git a/DisCatSharp.Hosting.Tests/HostTests.cs b/DisCatSharp.Hosting.Tests/HostTests.cs
index df546cb3f..b565873c7 100644
--- a/DisCatSharp.Hosting.Tests/HostTests.cs
+++ b/DisCatSharp.Hosting.Tests/HostTests.cs
@@ -1,143 +1,207 @@
 // This file is part of the DisCatSharp project, a fork of DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using DisCatSharp.Interactivity;
 using DisCatSharp.Lavalink;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Xunit;
 
 namespace DisCatSharp.Hosting.Tests
 {
     public class Bot : DiscordHostedService
     {
-        public Bot(IConfiguration config, ILogger<DiscordHostedService> logger, IServiceProvider provider) : base(config, logger, provider)
+        public Bot(IConfiguration config, ILogger<Bot> logger, IServiceProvider provider) : base(config, logger, provider)
+        {
+        }
+    }
+
+    public class MyCustomBot : DiscordHostedService
+    {
+        public MyCustomBot(IConfiguration config, ILogger<MyCustomBot> logger, IServiceProvider provider) : base(config, logger, provider, "MyCustomBot")
         {
         }
     }
 
     public class HostTests
     {
         private Dictionary<string, string> DefaultDiscord() =>
             new()
             {
                 { "DisCatSharp:Discord:Token", "1234567890" },
                 { "DisCatSharp:Discord:TokenType", "Bot" },
                 { "DisCatSharp:Discord:MinimumLogLevel", "Information" },
                 { "DisCatSharp:Discord:UseRelativeRateLimit", "true" },
                 { "DisCatSharp:Discord:LogTimestampFormat", "yyyy-MM-dd HH:mm:ss zzz" },
                 { "DisCatSharp:Discord:LargeThreshold", "250" },
                 { "DisCatSharp:Discord:AutoReconnect", "true" },
                 { "DisCatSharp:Discord:ShardId", "123123" },
                 { "DisCatSharp:Discord:GatewayCompressionLevel", "Stream" },
                 { "DisCatSharp:Discord:MessageCacheSize", "1024" },
                 { "DisCatSharp:Discord:HttpTimeout", "00:00:20" },
                 { "DisCatSharp:Discord:ReconnectIndefinitely", "false" },
                 { "DisCatSharp:Discord:AlwaysCacheMembers", "true" },
                 { "DisCatSharp:Discord:DiscordIntents", "AllUnprivileged" },
                 { "DisCatSharp:Discord:MobileStatus", "false" },
                 { "DisCatSharp:Discord:UseCanary", "false" },
                 { "DisCatSharp:Discord:AutoRefreshChannelCache", "false" },
                 { "DisCatSharp:Discord:Intents", "AllUnprivileged" }
             };
 
         public Dictionary<string, string> DiscordInteractivity() => new (this.DefaultDiscord())
         {
             {"DisCatSharp:Using","[\"DisCatSharp.Interactivity\"]"},
         };
 
         public Dictionary<string, string> DiscordInteractivityAndLavalink() => new (this.DefaultDiscord())
         {
             {"DisCatSharp:Using","[\"DisCatSharp.Interactivity\", \"DisCatSharp.Lavalink\"]"},
         };
 
         IHostBuilder Create(Dictionary<string, string> configValues) =>
             Host.CreateDefaultBuilder()
                 .ConfigureServices(services => services.AddSingleton<IDiscordHostedService, Bot>())
                 .ConfigureHostConfiguration(builder => builder.AddInMemoryCollection(configValues));
 
+        IHostBuilder Create(string filename) =>
+            Host.CreateDefaultBuilder()
+                .ConfigureServices(services => services.AddSingleton<IDiscordHostedService, MyCustomBot>())
+                .ConfigureHostConfiguration(builder => builder.AddJsonFile(filename));
+
+        [Fact]
+        public void TestDifferentSection_InteractivityOnly()
+        {
+            IHost? host = null;
+
+            try
+            {
+                host = this.Create("interactivity-different-section.json").Build();
+                var service = host.Services.GetRequiredService<IDiscordHostedService>();
+
+                Assert.NotNull(service);
+                Assert.NotNull(service.Client);
+                Assert.Null(service.Client.GetExtension<LavalinkExtension>());
+
+                var intents = DiscordIntents.GuildEmojisAndStickers | DiscordIntents.GuildMembers |
+                              DiscordIntents.Guilds;
+                Assert.Equal(intents, service.Client.Intents);
+
+
+                var interactivity = service.Client.GetExtension<InteractivityExtension>();
+                Assert.NotNull(interactivity);
+            }
+            finally
+            {
+                host?.Dispose();
+            }
+        }
+
+        [Fact]
+        public void TestDifferentSection_LavalinkOnly()
+        {
+            IHost? host = null;
+
+            try
+            {
+                host = this.Create("lavalink-different-section.json").Build();
+                var service = host.Services.GetRequiredService<IDiscordHostedService>();
+
+                Assert.NotNull(service);
+                Assert.NotNull(service.Client);
+                Assert.NotNull(service.Client.GetExtension<LavalinkExtension>());
+                Assert.Null(service.Client.GetExtension<InteractivityExtension>());
+
+                var intents = DiscordIntents.Guilds;
+                Assert.Equal(intents, service.Client.Intents);
+            }
+            finally
+            {
+                host?.Dispose();
+            }
+        }
+
         [Fact]
         public void TestNoExtensions()
         {
             IHost? host = null;
 
             try
             {
                 host = this.Create(this.DefaultDiscord()).Build();
 
                 var service = host.Services.GetRequiredService<IDiscordHostedService>();
                 Assert.NotNull(service);
                 Assert.NotNull(service.Client);
             }
             finally
             {
                 host?.Dispose();
             }
         }
 
         [Fact]
         public void TestInteractivityExtension()
         {
             IHost? host = null;
 
             try
             {
                 host = this.Create(this.DiscordInteractivity()).Build();
 
                 var service = host.Services.GetRequiredService<IDiscordHostedService>();
                 Assert.NotNull(service);
                 Assert.NotNull(service.Client);
                 Assert.NotNull(service.Client.GetExtension<InteractivityExtension>());
             }
             finally
             {
                 host?.Dispose();
             }
         }
 
         [Fact]
         public void TestInteractivityLavalinkExtensions()
         {
             IHost? host = null;
 
             try
             {
                 host = this.Create(this.DiscordInteractivityAndLavalink()).Build();
 
                 var service = host.Services.GetRequiredService<IDiscordHostedService>();
 
                 Assert.NotNull(service);
                 Assert.NotNull(service.Client);
                 Assert.NotNull(service.Client.GetExtension<InteractivityExtension>());
                 Assert.NotNull(service.Client.GetExtension<LavalinkExtension>());
             }
             finally
             {
                 host?.Dispose();
             }
         }
     }
 }
diff --git a/DisCatSharp.Hosting.Tests/interactivity-different-section.json b/DisCatSharp.Hosting.Tests/interactivity-different-section.json
new file mode 100644
index 000000000..1fdcef8fe
--- /dev/null
+++ b/DisCatSharp.Hosting.Tests/interactivity-different-section.json
@@ -0,0 +1,12 @@
+{
+    "MyCustomBot": {
+        "Using": [
+            "Interactivity"
+        ],
+
+        "Discord": {
+            "Token": "1234567890",
+            "Intents": "GuildEmojisAndStickers,GuildMembers,Guilds"
+        }
+    }
+}
diff --git a/DisCatSharp.Hosting.Tests/lavalink-different-section.json b/DisCatSharp.Hosting.Tests/lavalink-different-section.json
new file mode 100644
index 000000000..91d48b92f
--- /dev/null
+++ b/DisCatSharp.Hosting.Tests/lavalink-different-section.json
@@ -0,0 +1,12 @@
+{
+    "MyCustomBot": {
+        "Using": [
+            "Lavalink"
+        ],
+
+        "Discord": {
+            "Token": "1234567890",
+            "Intents": "Guilds"
+        }
+    }
+}
diff --git a/DisCatSharp.Hosting/DiscordHostedService.cs b/DisCatSharp.Hosting/DiscordHostedService.cs
index 39099f0c6..5cecc59c9 100644
--- a/DisCatSharp.Hosting/DiscordHostedService.cs
+++ b/DisCatSharp.Hosting/DiscordHostedService.cs
@@ -1,157 +1,159 @@
 // This file is part of the DisCatSharp project, a fork of DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Configuration;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Hosting
 {
     /// <summary>
     /// Simple implementation for <see cref="DiscordClient"/> to work as a <see cref="BackgroundService"/>
     /// </summary>
     public abstract class DiscordHostedService : BackgroundService, IDiscordHostedService
     {
         /// <inheritdoc/>
         public DiscordClient Client { get; private set; }
 
         protected readonly ILogger<DiscordHostedService> Logger;
 
         #pragma warning disable 8618
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordHostedService"/> class.
         /// </summary>
         /// <param name="config">The config.</param>
         /// <param name="logger">The logger.</param>
         /// <param name="provider">The provider.</param>
-        protected DiscordHostedService(IConfiguration config, ILogger<DiscordHostedService> logger, IServiceProvider provider)
+        /// <param name="configBotSection">Name within the configuration which contains the config info for our bot. Default is DisCatSharp</param>
+        protected DiscordHostedService(IConfiguration config, ILogger<DiscordHostedService> logger, IServiceProvider provider, string configBotSection = Configuration.ConfigurationExtensions.DefaultRootLib)
         {
             this.Logger = logger;
-            this.Initialize(config, provider);
+            this.Initialize(config, provider, configBotSection);
         }
 
         #pragma warning restore 8618
 
         /// <summary>
         /// Automatically search for and configure <see cref="Client"/>
         /// </summary>
         /// <param name="config"></param>
         /// <param name="provider"></param>
-        private void Initialize(IConfiguration config, IServiceProvider provider)
+        /// <param name="configBotSection">Name within the configuration which contains the config info for our bot</param>
+        private void Initialize(IConfiguration config, IServiceProvider provider, string configBotSection)
         {
-            var typeMap = config.FindImplementedExtensions();
+            var typeMap = config.FindImplementedExtensions(configBotSection);
 
             this.Logger.LogDebug($"Found the following config types: {string.Join("\n\t", typeMap.Keys)}");
 
-            this.Client = config.BuildClient();
+            this.Client = config.BuildClient(configBotSection);
 
             foreach (var typePair in typeMap)
                 try
                 {
                     /*
                         If section is null --> utilize the default constructor
                         This means the extension was explicitly added in the 'Using' array,
                         but user did not wish to override any value(s) in the extension's config
                      */
 
                     var configInstance = typePair.Value.Section.HasValue
                         ? typePair.Value.Section.Value.ExtractConfig(() =>
                             ActivatorUtilities.CreateInstance(provider, typePair.Value.ConfigType))
                         : ActivatorUtilities.CreateInstance(provider, typePair.Value.ConfigType);
 
                     /*
                         Explanation for bindings
 
                         Internal Constructors --> NonPublic
                         Public Constructors --> Public
                         Constructors --> Instance
                      */
 
                     var flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
                     var ctors = typePair.Value.ImplementationType.GetConstructors(flags);
 
                     var instance = ctors.Any(x => x.GetParameters().Length == 1 && x.GetParameters().First().ParameterType == typePair.Value.ConfigType)
                         ? Activator.CreateInstance(typePair.Value.ImplementationType, flags, null,
                                                     new[] { configInstance }, null)
                         : Activator.CreateInstance(typePair.Value.ImplementationType, true);
 
                     /*
                        Certain extensions do not require a configuration argument
                        Those who do -- pass config instance in,
                        Those who don't -- simply instantiate
 
                        ActivatorUtilities requires a public constructor, anything with internal breaks
                      */
 
 
                     if (instance == null)
                     {
                         this.Logger.LogError($"Unable to instantiate '{typePair.Value.ImplementationType.Name}'");
                         continue;
                     }
 
                     // Add an easy reference to our extensions for later use
                     this.Client.AddExtension((BaseExtension)instance);
                 }
                 catch (Exception ex)
                 {
                     this.Logger.LogError($"Unable to register '{typePair.Value.ImplementationType.Name}': \n\t{ex.Message}");
                 }
         }
 
         /// <summary>
         /// Executes the bot.
         /// </summary>
         /// <param name="stoppingToken">The stopping token.</param>
         /// <returns>A Task.</returns>
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
             if (this.Client == null)
                 throw new NullReferenceException("Discord Client cannot be null");
 
             await this.PreConnect();
             await this.Client.ConnectAsync();
             await this.PostConnect();
 
             // Wait indefinitely -- but use stopping token so we can properly cancel if needed
             await Task.Delay(-1, stoppingToken);
         }
 
         /// <summary>
         /// Runs just prior to the bot connecting
         /// </summary>
         protected virtual Task PreConnect() => Task.CompletedTask;
 
         /// <summary>
         /// Runs immediately after the bot connects
         /// </summary>
         protected virtual Task PostConnect() => Task.CompletedTask;
 
     }
 }
diff --git a/DisCatSharp.Hosting/IDiscordHostedService.cs b/DisCatSharp.Hosting/IDiscordHostedService.cs
index 353a4a99e..22c5ee59f 100644
--- a/DisCatSharp.Hosting/IDiscordHostedService.cs
+++ b/DisCatSharp.Hosting/IDiscordHostedService.cs
@@ -1,38 +1,36 @@
 // This file is part of the DisCatSharp project, a fork of DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-using System.Collections.Generic;
-
 namespace DisCatSharp.Hosting
 {
 
     /// <summary>
     /// Contract required for <see cref="DiscordClient"/> to work in a web hosting environment
     /// </summary>
     public interface IDiscordHostedService : Microsoft.Extensions.Hosting.IHostedService
     {
         /// <summary>
         /// Reference to connected client
         /// </summary>
         DiscordClient Client { get; }
     }
 }