diff --git a/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/Channel/ChannelBase.cs b/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/Channel/ChannelBase.cs
index d625d10e..7e8330a3 100644
--- a/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/Channel/ChannelBase.cs
+++ b/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/Channel/ChannelBase.cs
@@ -23,7 +23,7 @@ namespace Microsoft.SqlTools.Hosting.Protocol.Channel
         /// <summary>
         /// Gets the MessageReader for reading messages from the channel.
         /// </summary>
-        public MessageReader MessageReader { get; protected set; }
+        public virtual MessageReader MessageReader { get; protected set; } // mark as virtual for mocking ChannelBase in UT
 
         /// <summary>
         /// Gets the MessageWriter for writing messages to the channel.
diff --git a/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/IProtocolEndpoint.cs b/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/IProtocolEndpoint.cs
index e0adefab..85d9318c 100644
--- a/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/IProtocolEndpoint.cs
+++ b/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/IProtocolEndpoint.cs
@@ -16,17 +16,43 @@ namespace Microsoft.SqlTools.Hosting.Protocol
     /// </summary>
     public interface IProtocolEndpoint : IEventSender, IRequestSender
     {
+        /// <summary>
+        /// Set a request handler
+        /// </summary>
+        /// <typeparam name="TParams">type of parameter</typeparam>
+        /// <typeparam name="TResult">type of result</typeparam>
+        /// <param name="requestType">request type</param>
+        /// <param name="requestHandler">request handler</param>
+        /// <param name="isParallelProcessingSupported">whether this handler supports parallel processing</param>
         void SetRequestHandler<TParams, TResult>(
             RequestType<TParams, TResult> requestType,
-            Func<TParams, RequestContext<TResult>, Task> requestHandler);
-
-        void SetEventHandler<TParams>(
-            EventType<TParams> eventType,
-            Func<TParams, EventContext, Task> eventHandler);
+            Func<TParams, RequestContext<TResult>, Task> requestHandler,
+            bool isParallelProcessingSupported = false);
 
+        /// <summary>
+        /// Set an request handler
+        /// </summary>
+        /// <typeparam name="TParams">type of parameter</typeparam>
+        /// <param name="eventType">type of event</param>
+        /// <param name="eventHandler">event handler</param>
+        /// <param name="isParallelProcessingSupported">whether this handler supports parallel processing</param>
         void SetEventHandler<TParams>(
             EventType<TParams> eventType,
             Func<TParams, EventContext, Task> eventHandler,
-            bool overrideExisting);
+            bool isParallelProcessingSupported = false);
+
+        /// <summary>
+        /// Set an request handler
+        /// </summary>
+        /// <typeparam name="TParams">type of parameter</typeparam>
+        /// <param name="eventType">type of event</param>
+        /// <param name="eventHandler">event handler</param>
+        /// <param name="overrideExisting">whether to override the existing handler for the same event type</param>
+        /// <param name="isParallelProcessingSupported">whether this handler supports parallel processing</param>
+        void SetEventHandler<TParams>(
+            EventType<TParams> eventType,
+            Func<TParams, EventContext, Task> eventHandler,
+            bool overrideExisting,
+            bool isParallelProcessingSupported = false);
     }
 }
diff --git a/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/MessageDispatcher.cs b/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/MessageDispatcher.cs
index 99d78c9b..7f1b9eb4 100644
--- a/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/MessageDispatcher.cs
+++ b/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/MessageDispatcher.cs
@@ -27,14 +27,22 @@ namespace Microsoft.SqlTools.Hosting.Protocol
         internal Dictionary<string, Func<Message, MessageWriter, Task>> requestHandlers =
             new Dictionary<string, Func<Message, MessageWriter, Task>>();
 
+        internal Dictionary<string, bool> requestHandlerParallelismMap =
+            new Dictionary<string, bool>();
+
         internal Dictionary<string, Func<Message, MessageWriter, Task>> eventHandlers =
             new Dictionary<string, Func<Message, MessageWriter, Task>>();
 
+        internal Dictionary<string, bool> eventHandlerParallelismMap =
+            new Dictionary<string, bool>();
+
         private Action<Message> responseHandler;
 
         private CancellationTokenSource messageLoopCancellationToken =
             new CancellationTokenSource();
 
+        private SemaphoreSlim semaphore = new SemaphoreSlim(10); // Limit to 10 threads to begin with, ideally there shouldn't be any limitation
+
         #endregion
 
         #region Properties
@@ -112,7 +120,8 @@ namespace Microsoft.SqlTools.Hosting.Protocol
         public void SetRequestHandler<TParams, TResult>(
             RequestType<TParams, TResult> requestType,
             Func<TParams, RequestContext<TResult>, Task> requestHandler,
-            bool overrideExisting)
+            bool overrideExisting,
+            bool isParallelProcessingSupported = false)
         {
             if (overrideExisting)
             {
@@ -120,16 +129,18 @@ namespace Microsoft.SqlTools.Hosting.Protocol
                 this.requestHandlers.Remove(requestType.MethodName);
             }
 
+            this.requestHandlerParallelismMap.Add(requestType.MethodName, isParallelProcessingSupported);
             this.requestHandlers.Add(
                 requestType.MethodName,
                 async (requestMessage, messageWriter) =>
                 {
+                    Logger.Write(TraceEventType.Verbose, $"Processing message with id[{requestMessage.Id}], of type[{requestMessage.MessageType}] and method[{requestMessage.Method}]");
                     var requestContext =
                         new RequestContext<TResult>(
                             requestMessage,
                             messageWriter);
                     try
-                    {                        
+                    {
                         TParams typedParams = default(TParams);
                         if (requestMessage.Contents != null)
                         {
@@ -144,6 +155,7 @@ namespace Microsoft.SqlTools.Hosting.Protocol
                         }
 
                         await requestHandler(typedParams, requestContext);
+                        Logger.Write(TraceEventType.Verbose, $"Finished processing message with id[{requestMessage.Id}], of type[{requestMessage.MessageType}] and method[{requestMessage.Method}]");
                     }
                     catch (Exception ex)
                     {
@@ -166,7 +178,8 @@ namespace Microsoft.SqlTools.Hosting.Protocol
         public void SetEventHandler<TParams>(
             EventType<TParams> eventType,
             Func<TParams, EventContext, Task> eventHandler,
-            bool overrideExisting)
+            bool overrideExisting,
+            bool isParallelProcessingSupported = false)
         {
             if (overrideExisting)
             {
@@ -174,14 +187,16 @@ namespace Microsoft.SqlTools.Hosting.Protocol
                 this.eventHandlers.Remove(eventType.MethodName);
             }
 
+            this.eventHandlerParallelismMap.Add(eventType.MethodName, isParallelProcessingSupported);
             this.eventHandlers.Add(
                 eventType.MethodName,
                 async (eventMessage, messageWriter) =>
                 {
+                    Logger.Write(TraceEventType.Verbose, $"Processing message with id[{eventMessage.Id}], of type[{eventMessage.MessageType}] and method[{eventMessage.Method}]");
                     var eventContext = new EventContext(messageWriter);
                     TParams typedParams = default(TParams);
                     try
-                    {                
+                    {
                         if (eventMessage.Contents != null)
                         {
                             try
@@ -194,6 +209,7 @@ namespace Microsoft.SqlTools.Hosting.Protocol
                             }
                         }
                         await eventHandler(typedParams, eventContext);
+                        Logger.Write(TraceEventType.Verbose, $"Finished processing message with id[{eventMessage.Id}], of type[{eventMessage.MessageType}] and method[{eventMessage.Method}]");
                     }
                     catch (Exception ex)
                     {
@@ -284,19 +300,13 @@ namespace Microsoft.SqlTools.Hosting.Protocol
             Message messageToDispatch,
             MessageWriter messageWriter)
         {
-            Task handlerToAwait = null;
+            Func<Message, MessageWriter, Task> handlerToAwait = null;
+            bool isParallelProcessingSupported = false;
 
             if (messageToDispatch.MessageType == MessageType.Request)
             {
-                Func<Message, MessageWriter, Task> requestHandler = null;
-                if (this.requestHandlers.TryGetValue(messageToDispatch.Method, out requestHandler))
-                {
-                    handlerToAwait = requestHandler(messageToDispatch, messageWriter);
-                }
-                // else
-                // {
-                //     // TODO: Message not supported error
-                // }
+                this.requestHandlers.TryGetValue(messageToDispatch.Method, out handlerToAwait);
+                this.requestHandlerParallelismMap.TryGetValue(messageToDispatch.Method, out isParallelProcessingSupported);
             }
             else if (messageToDispatch.MessageType == MessageType.Response)
             {
@@ -307,15 +317,8 @@ namespace Microsoft.SqlTools.Hosting.Protocol
             }
             else if (messageToDispatch.MessageType == MessageType.Event)
             {
-                Func<Message, MessageWriter, Task> eventHandler = null;
-                if (this.eventHandlers.TryGetValue(messageToDispatch.Method, out eventHandler))
-                {
-                    handlerToAwait = eventHandler(messageToDispatch, messageWriter);
-                }
-                else
-                {
-                    // TODO: Message not supported error
-                }
+                this.eventHandlers.TryGetValue(messageToDispatch.Method, out handlerToAwait);
+                this.eventHandlerParallelismMap.TryGetValue(messageToDispatch.Method, out isParallelProcessingSupported);
             }
             // else
             // {
@@ -324,39 +327,37 @@ namespace Microsoft.SqlTools.Hosting.Protocol
 
             if (handlerToAwait != null)
             {
-                if (this.ParallelMessageProcessing)
+                try
                 {
-                    // Run the task in a separate thread so that the main
-                    // thread is not blocked.
-                    _ = Task.Run(() =>
+                    if (this.ParallelMessageProcessing && isParallelProcessingSupported)
                     {
-                        _ = RunTask(handlerToAwait);
-                    });
+                        // Run the task in a separate thread so that the main
+                        // thread is not blocked. Use semaphore to limit the degree of parallelism.
+                        await semaphore.WaitAsync();
+                        _ = Task.Run(async () =>
+                        {
+                            await handlerToAwait(messageToDispatch, messageWriter);
+                            semaphore.Release();
+                        });
+                    }
+                    else
+                    {
+                        await handlerToAwait(messageToDispatch, messageWriter);
+                    }
                 }
-                else
+                catch (TaskCanceledException e)
                 {
-                    await RunTask(handlerToAwait);
+                    // Some tasks may be cancelled due to legitimate
+                    // timeouts so don't let those exceptions go higher.
+                    Logger.Write(TraceEventType.Verbose, string.Format("A TaskCanceledException occurred in the request handler: {0}", e.ToString()));
                 }
-            }
-        }
-
-        private async Task RunTask(Task task)
-        {
-            try
-            {
-                await task;
-            }
-            catch (TaskCanceledException)
-            {
-                // Some tasks may be cancelled due to legitimate
-                // timeouts so don't let those exceptions go higher.
-            }
-            catch (Exception e)
-            {
-                if (!(e is AggregateException && ((AggregateException)e).InnerExceptions[0] is TaskCanceledException))
+                catch (Exception e)
                 {
-                    // Log the error but don't rethrow it to prevent any errors in the handler from crashing the service
-                    Logger.Write(TraceEventType.Error, string.Format("An unexpected error occured in the request handler: {0}", e.ToString()));
+                    if (!(e is AggregateException && ((AggregateException)e).InnerExceptions[0] is TaskCanceledException))
+                    {
+                        // Log the error but don't rethrow it to prevent any errors in the handler from crashing the service
+                        Logger.Write(TraceEventType.Error, string.Format("An unexpected error occurred in the request handler: {0}", e.ToString()));
+                    }
                 }
             }
         }
diff --git a/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/MessageReader.cs b/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/MessageReader.cs
index f7f171de..2de51a8d 100644
--- a/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/MessageReader.cs
+++ b/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/MessageReader.cs
@@ -49,6 +49,7 @@ namespace Microsoft.SqlTools.Hosting.Protocol
         #endregion
 
         #region Constructors
+        public MessageReader() {} // added for mocking MessageReader in UT
 
         public MessageReader(
             Stream inputStream,
@@ -74,7 +75,7 @@ namespace Microsoft.SqlTools.Hosting.Protocol
 
         #region Public Methods
 
-        public async Task<Message> ReadMessage()
+        public virtual async Task<Message> ReadMessage() // mark as virtual for mocking MessageReader in UT
         {
             string messageContent = null;
 
diff --git a/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/ProtocolEndpoint.cs b/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/ProtocolEndpoint.cs
index 4337a4a8..e6b65b30 100644
--- a/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/ProtocolEndpoint.cs
+++ b/src/Microsoft.SqlTools.Hosting/Hosting/Protocol/ProtocolEndpoint.cs
@@ -272,32 +272,39 @@ namespace Microsoft.SqlTools.Hosting.Protocol
 
         public void SetRequestHandler<TParams, TResult>(
             RequestType<TParams, TResult> requestType,
-            Func<TParams, RequestContext<TResult>, Task> requestHandler)
+            Func<TParams, RequestContext<TResult>, Task> requestHandler,
+            bool isParallelProcessingSupported = false)
         {
             this.MessageDispatcher.SetRequestHandler(
                 requestType,
-                requestHandler);
-        }
-
-        public void SetEventHandler<TParams>(
-            EventType<TParams> eventType,
-            Func<TParams, EventContext, Task> eventHandler)
-        {
-            this.MessageDispatcher.SetEventHandler(
-                eventType,
-                eventHandler,
-                false);
+                requestHandler,
+                false,
+                isParallelProcessingSupported);
         }
 
         public void SetEventHandler<TParams>(
             EventType<TParams> eventType,
             Func<TParams, EventContext, Task> eventHandler,
-            bool overrideExisting)
+            bool isParallelProcessingSupported = false)
         {
             this.MessageDispatcher.SetEventHandler(
                 eventType,
                 eventHandler,
-                overrideExisting);
+                false,
+                isParallelProcessingSupported);
+        }
+
+        public void SetEventHandler<TParams>(
+            EventType<TParams> eventType,
+            Func<TParams, EventContext, Task> eventHandler,
+            bool overrideExisting,
+            bool isParallelProcessingSupported = false)
+        {
+            this.MessageDispatcher.SetEventHandler(
+                eventType,
+                eventHandler,
+                overrideExisting,
+                isParallelProcessingSupported);
         }
 
         private void HandleResponse(Message responseMessage)
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Admin/AdminService.cs b/src/Microsoft.SqlTools.ServiceLayer/Admin/AdminService.cs
index 02c48d03..2cd5aea4 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Admin/AdminService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Admin/AdminService.cs
@@ -65,10 +65,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Admin
         /// </summary>
         public void InitializeService(ServiceHost serviceHost)
         {
-            serviceHost.SetRequestHandler(CreateDatabaseRequest.Type, HandleCreateDatabaseRequest);
-            serviceHost.SetRequestHandler(CreateLoginRequest.Type, HandleCreateLoginRequest);
-            serviceHost.SetRequestHandler(DefaultDatabaseInfoRequest.Type, HandleDefaultDatabaseInfoRequest);
-            serviceHost.SetRequestHandler(GetDatabaseInfoRequest.Type, HandleGetDatabaseInfoRequest);
+            serviceHost.SetRequestHandler(CreateDatabaseRequest.Type, HandleCreateDatabaseRequest, true);
+            serviceHost.SetRequestHandler(CreateLoginRequest.Type, HandleCreateLoginRequest, true);
+            serviceHost.SetRequestHandler(DefaultDatabaseInfoRequest.Type, HandleDefaultDatabaseInfoRequest, true);
+            serviceHost.SetRequestHandler(GetDatabaseInfoRequest.Type, HandleGetDatabaseInfoRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Agent/AgentService.cs b/src/Microsoft.SqlTools.ServiceLayer/Agent/AgentService.cs
index 3a5a93d9..9917150b 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Agent/AgentService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Agent/AgentService.cs
@@ -79,56 +79,56 @@ namespace Microsoft.SqlTools.ServiceLayer.Agent
             this.ServiceHost = serviceHost;
 
             // Jobs request handlers
-            this.ServiceHost.SetRequestHandler(AgentJobsRequest.Type, HandleAgentJobsRequest);
-            this.ServiceHost.SetRequestHandler(AgentJobHistoryRequest.Type, HandleJobHistoryRequest);
-            this.ServiceHost.SetRequestHandler(AgentJobActionRequest.Type, HandleJobActionRequest);
+            this.ServiceHost.SetRequestHandler(AgentJobsRequest.Type, HandleAgentJobsRequest, true);
+            this.ServiceHost.SetRequestHandler(AgentJobHistoryRequest.Type, HandleJobHistoryRequest, true);
+            this.ServiceHost.SetRequestHandler(AgentJobActionRequest.Type, HandleJobActionRequest, true);
 
-            this.ServiceHost.SetRequestHandler(CreateAgentJobRequest.Type, HandleCreateAgentJobRequest);
-            this.ServiceHost.SetRequestHandler(UpdateAgentJobRequest.Type, HandleUpdateAgentJobRequest);
-            this.ServiceHost.SetRequestHandler(DeleteAgentJobRequest.Type, HandleDeleteAgentJobRequest);
+            this.ServiceHost.SetRequestHandler(CreateAgentJobRequest.Type, HandleCreateAgentJobRequest, true);
+            this.ServiceHost.SetRequestHandler(UpdateAgentJobRequest.Type, HandleUpdateAgentJobRequest, true);
+            this.ServiceHost.SetRequestHandler(DeleteAgentJobRequest.Type, HandleDeleteAgentJobRequest, true);
 
-            this.ServiceHost.SetRequestHandler(AgentJobDefaultsRequest.Type, HandleAgentJobDefaultsRequest);
+            this.ServiceHost.SetRequestHandler(AgentJobDefaultsRequest.Type, HandleAgentJobDefaultsRequest, true);
 
             // Job Steps request handlers
-            this.ServiceHost.SetRequestHandler(CreateAgentJobStepRequest.Type, HandleCreateAgentJobStepRequest);
-            this.ServiceHost.SetRequestHandler(UpdateAgentJobStepRequest.Type, HandleUpdateAgentJobStepRequest);
-            this.ServiceHost.SetRequestHandler(DeleteAgentJobStepRequest.Type, HandleDeleteAgentJobStepRequest);
+            this.ServiceHost.SetRequestHandler(CreateAgentJobStepRequest.Type, HandleCreateAgentJobStepRequest, true);
+            this.ServiceHost.SetRequestHandler(UpdateAgentJobStepRequest.Type, HandleUpdateAgentJobStepRequest, true);
+            this.ServiceHost.SetRequestHandler(DeleteAgentJobStepRequest.Type, HandleDeleteAgentJobStepRequest, true);
 
             // Alerts request handlers
-            this.ServiceHost.SetRequestHandler(AgentAlertsRequest.Type, HandleAgentAlertsRequest);
-            this.ServiceHost.SetRequestHandler(CreateAgentAlertRequest.Type, HandleCreateAgentAlertRequest);
-            this.ServiceHost.SetRequestHandler(UpdateAgentAlertRequest.Type, HandleUpdateAgentAlertRequest);
-            this.ServiceHost.SetRequestHandler(DeleteAgentAlertRequest.Type, HandleDeleteAgentAlertRequest);
+            this.ServiceHost.SetRequestHandler(AgentAlertsRequest.Type, HandleAgentAlertsRequest, true);
+            this.ServiceHost.SetRequestHandler(CreateAgentAlertRequest.Type, HandleCreateAgentAlertRequest, true);
+            this.ServiceHost.SetRequestHandler(UpdateAgentAlertRequest.Type, HandleUpdateAgentAlertRequest, true);
+            this.ServiceHost.SetRequestHandler(DeleteAgentAlertRequest.Type, HandleDeleteAgentAlertRequest, true);
 
             // Operators request handlers
-            this.ServiceHost.SetRequestHandler(AgentOperatorsRequest.Type, HandleAgentOperatorsRequest);
-            this.ServiceHost.SetRequestHandler(CreateAgentOperatorRequest.Type, HandleCreateAgentOperatorRequest);
-            this.ServiceHost.SetRequestHandler(UpdateAgentOperatorRequest.Type, HandleUpdateAgentOperatorRequest);
-            this.ServiceHost.SetRequestHandler(DeleteAgentOperatorRequest.Type, HandleDeleteAgentOperatorRequest);
+            this.ServiceHost.SetRequestHandler(AgentOperatorsRequest.Type, HandleAgentOperatorsRequest, true);
+            this.ServiceHost.SetRequestHandler(CreateAgentOperatorRequest.Type, HandleCreateAgentOperatorRequest, true);
+            this.ServiceHost.SetRequestHandler(UpdateAgentOperatorRequest.Type, HandleUpdateAgentOperatorRequest, true);
+            this.ServiceHost.SetRequestHandler(DeleteAgentOperatorRequest.Type, HandleDeleteAgentOperatorRequest, true);
 
             // Proxy Accounts request handlers
-            this.ServiceHost.SetRequestHandler(AgentProxiesRequest.Type, HandleAgentProxiesRequest);
-            this.ServiceHost.SetRequestHandler(CreateAgentProxyRequest.Type, HandleCreateAgentProxyRequest);
-            this.ServiceHost.SetRequestHandler(UpdateAgentProxyRequest.Type, HandleUpdateAgentProxyRequest);
-            this.ServiceHost.SetRequestHandler(DeleteAgentProxyRequest.Type, HandleDeleteAgentProxyRequest);
+            this.ServiceHost.SetRequestHandler(AgentProxiesRequest.Type, HandleAgentProxiesRequest, true);
+            this.ServiceHost.SetRequestHandler(CreateAgentProxyRequest.Type, HandleCreateAgentProxyRequest, true);
+            this.ServiceHost.SetRequestHandler(UpdateAgentProxyRequest.Type, HandleUpdateAgentProxyRequest, true);
+            this.ServiceHost.SetRequestHandler(DeleteAgentProxyRequest.Type, HandleDeleteAgentProxyRequest, true);
 
             // Schedule request handlers
-            this.ServiceHost.SetRequestHandler(AgentSchedulesRequest.Type, HandleAgentSchedulesRequest);
-            this.ServiceHost.SetRequestHandler(CreateAgentScheduleRequest.Type, HandleCreateAgentScheduleRequest);
-            this.ServiceHost.SetRequestHandler(UpdateAgentScheduleRequest.Type, HandleUpdateAgentScheduleRequest);
-            this.ServiceHost.SetRequestHandler(DeleteAgentScheduleRequest.Type, HandleDeleteAgentScheduleRequest);
+            this.ServiceHost.SetRequestHandler(AgentSchedulesRequest.Type, HandleAgentSchedulesRequest, true);
+            this.ServiceHost.SetRequestHandler(CreateAgentScheduleRequest.Type, HandleCreateAgentScheduleRequest, true);
+            this.ServiceHost.SetRequestHandler(UpdateAgentScheduleRequest.Type, HandleUpdateAgentScheduleRequest, true);
+            this.ServiceHost.SetRequestHandler(DeleteAgentScheduleRequest.Type, HandleDeleteAgentScheduleRequest, true);
 
             // Notebook request handlers
-            this.ServiceHost.SetRequestHandler(AgentNotebooksRequest.Type, HandleAgentNotebooksRequest);
-            this.ServiceHost.SetRequestHandler(AgentNotebookHistoryRequest.Type, HandleAgentNotebookHistoryRequest);
-            this.ServiceHost.SetRequestHandler(AgentNotebookMaterializedRequest.Type, HandleAgentNotebookMaterializedRequest);
-            this.ServiceHost.SetRequestHandler(AgentNotebookTemplateRequest.Type, HandleAgentNotebookTemplateRequest);
-            this.ServiceHost.SetRequestHandler(CreateAgentNotebookRequest.Type, HandleCreateAgentNotebookRequest);
-            this.ServiceHost.SetRequestHandler(DeleteAgentNotebookRequest.Type, HandleDeleteAgentNotebooksRequest);
-            this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRequest.Type, HandleUpdateAgentNotebookRequest);
-            this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRunPinRequest.Type, HandleUpdateAgentNotebookRunPinRequest);
-            this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRunNameRequest.Type, HandleUpdateAgentNotebookRunNameRequest);
-            this.ServiceHost.SetRequestHandler(DeleteNotebookMaterializedRequest.Type, HandleDeleteNotebookMaterializedRequest);
+            this.ServiceHost.SetRequestHandler(AgentNotebooksRequest.Type, HandleAgentNotebooksRequest, true);
+            this.ServiceHost.SetRequestHandler(AgentNotebookHistoryRequest.Type, HandleAgentNotebookHistoryRequest, true);
+            this.ServiceHost.SetRequestHandler(AgentNotebookMaterializedRequest.Type, HandleAgentNotebookMaterializedRequest, true);
+            this.ServiceHost.SetRequestHandler(AgentNotebookTemplateRequest.Type, HandleAgentNotebookTemplateRequest, true);
+            this.ServiceHost.SetRequestHandler(CreateAgentNotebookRequest.Type, HandleCreateAgentNotebookRequest, true);
+            this.ServiceHost.SetRequestHandler(DeleteAgentNotebookRequest.Type, HandleDeleteAgentNotebooksRequest, true);
+            this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRequest.Type, HandleUpdateAgentNotebookRequest, true);
+            this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRunPinRequest.Type, HandleUpdateAgentNotebookRunPinRequest, true);
+            this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRunNameRequest.Type, HandleUpdateAgentNotebookRunNameRequest, true);
+            this.ServiceHost.SetRequestHandler(DeleteNotebookMaterializedRequest.Type, HandleDeleteNotebookMaterializedRequest, true);
 
             serviceHost.RegisterShutdownTask((_, _) =>
             {
@@ -1194,7 +1194,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Agent
                     parameters.OwnerUri,
                     out connInfo);
                 result.Success = true;
-                result.Notebooks = AgentNotebookHelper.GetAgentNotebooks(connInfo).Result;
+                result.Notebooks = await AgentNotebookHelper.GetAgentNotebooks(connInfo);
             }
             catch (Exception e)
             {
@@ -1243,7 +1243,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Agent
                 ConnectionServiceInstance.TryFindConnection(
                                             parameters.OwnerUri,
                                             out connInfo);
-                result.NotebookMaterialized = AgentNotebookHelper.GetMaterializedNotebook(connInfo, parameters.NotebookMaterializedId, parameters.TargetDatabase).Result;
+                result.NotebookMaterialized = await AgentNotebookHelper.GetMaterializedNotebook(connInfo, parameters.NotebookMaterializedId, parameters.TargetDatabase);
                 result.Success = true;
             }
             catch (Exception e)
diff --git a/src/Microsoft.SqlTools.ServiceLayer/AzureBlob/BlobService.cs b/src/Microsoft.SqlTools.ServiceLayer/AzureBlob/BlobService.cs
index 4bbb5f57..5310ab38 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/AzureBlob/BlobService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/AzureBlob/BlobService.cs
@@ -35,7 +35,7 @@ namespace Microsoft.SqlTools.ServiceLayer.AzureBlob
 
         public void InitializeService(IProtocolEndpoint serviceHost)
         {
-            serviceHost.SetRequestHandler(CreateSasRequest.Type, HandleCreateSasRequest);
+            serviceHost.SetRequestHandler(CreateSasRequest.Type, HandleCreateSasRequest, true);
         }
 
         internal async Task HandleCreateSasRequest(
diff --git a/src/Microsoft.SqlTools.ServiceLayer/AzureFunctions/AzureFunctionsService.cs b/src/Microsoft.SqlTools.ServiceLayer/AzureFunctions/AzureFunctionsService.cs
index d5c2884c..684cf8dd 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/AzureFunctions/AzureFunctionsService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/AzureFunctions/AzureFunctionsService.cs
@@ -32,8 +32,8 @@ namespace Microsoft.SqlTools.ServiceLayer.AzureFunctions
         /// <param name="serviceHost"></param>
         public void InitializeService(ServiceHost serviceHost)
         {
-            serviceHost.SetRequestHandler(AddSqlBindingRequest.Type, this.HandleAddSqlBindingRequest);
-            serviceHost.SetRequestHandler(GetAzureFunctionsRequest.Type, this.HandleGetAzureFunctionsRequest);
+            serviceHost.SetRequestHandler(AddSqlBindingRequest.Type, this.HandleAddSqlBindingRequest, true);
+            serviceHost.SetRequestHandler(GetAzureFunctionsRequest.Type, this.HandleGetAzureFunctionsRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Cms/CmsService.cs b/src/Microsoft.SqlTools.ServiceLayer/Cms/CmsService.cs
index 338334a9..6921cda1 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Cms/CmsService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Cms/CmsService.cs
@@ -43,12 +43,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Cms
         /// <param name="serviceHost"></param>
         public void InitializeService(ServiceHost serviceHost)
         {
-            serviceHost.SetRequestHandler(CreateCentralManagementServerRequest.Type, this.HandleCreateCentralManagementServerRequest);
-            serviceHost.SetRequestHandler(ListRegisteredServersRequest.Type, this.HandleListRegisteredServersRequest);
-            serviceHost.SetRequestHandler(AddRegisteredServerRequest.Type, this.HandleAddRegisteredServerRequest);
-            serviceHost.SetRequestHandler(RemoveRegisteredServerRequest.Type, this.HandleRemoveRegisteredServerRequest);
-            serviceHost.SetRequestHandler(AddServerGroupRequest.Type, this.HandleAddServerGroupRequest);
-            serviceHost.SetRequestHandler(RemoveServerGroupRequest.Type, this.HandleRemoveServerGroupRequest);
+            serviceHost.SetRequestHandler(CreateCentralManagementServerRequest.Type, this.HandleCreateCentralManagementServerRequest, true);
+            serviceHost.SetRequestHandler(ListRegisteredServersRequest.Type, this.HandleListRegisteredServersRequest, true);
+            serviceHost.SetRequestHandler(AddRegisteredServerRequest.Type, this.HandleAddRegisteredServerRequest, true);
+            serviceHost.SetRequestHandler(RemoveRegisteredServerRequest.Type, this.HandleRemoveRegisteredServerRequest, true);
+            serviceHost.SetRequestHandler(AddServerGroupRequest.Type, this.HandleAddServerGroupRequest, true);
+            serviceHost.SetRequestHandler(RemoveServerGroupRequest.Type, this.HandleRemoveServerGroupRequest, true);
         }
 
         public async Task HandleCreateCentralManagementServerRequest(CreateCentralManagementServerParams createCmsParams, RequestContext<ListRegisteredServersResult> requestContext)
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs b/src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs
index 0521326f..d485ca97 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs
@@ -1059,14 +1059,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
             this.ServiceHost = serviceHost;
 
             // Register request and event handlers with the Service Host
-            serviceHost.SetRequestHandler(ConnectionRequest.Type, HandleConnectRequest);
-            serviceHost.SetRequestHandler(CancelConnectRequest.Type, HandleCancelConnectRequest);
-            serviceHost.SetRequestHandler(ChangePasswordRequest.Type, HandleChangePasswordRequest);
-            serviceHost.SetRequestHandler(DisconnectRequest.Type, HandleDisconnectRequest);
-            serviceHost.SetRequestHandler(ListDatabasesRequest.Type, HandleListDatabasesRequest);
-            serviceHost.SetRequestHandler(ChangeDatabaseRequest.Type, HandleChangeDatabaseRequest);
-            serviceHost.SetRequestHandler(GetConnectionStringRequest.Type, HandleGetConnectionStringRequest);
-            serviceHost.SetRequestHandler(BuildConnectionInfoRequest.Type, HandleBuildConnectionInfoRequest);
+            serviceHost.SetRequestHandler(ConnectionRequest.Type, HandleConnectRequest, true);
+            serviceHost.SetRequestHandler(CancelConnectRequest.Type, HandleCancelConnectRequest, true);
+            serviceHost.SetRequestHandler(ChangePasswordRequest.Type, HandleChangePasswordRequest, true);
+            serviceHost.SetRequestHandler(DisconnectRequest.Type, HandleDisconnectRequest, true);
+            serviceHost.SetRequestHandler(ListDatabasesRequest.Type, HandleListDatabasesRequest, true);
+            serviceHost.SetRequestHandler(ChangeDatabaseRequest.Type, HandleChangeDatabaseRequest, true);
+            serviceHost.SetRequestHandler(GetConnectionStringRequest.Type, HandleGetConnectionStringRequest, true);
+            serviceHost.SetRequestHandler(BuildConnectionInfoRequest.Type, HandleBuildConnectionInfoRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/DacFx/DacFxService.cs b/src/Microsoft.SqlTools.ServiceLayer/DacFx/DacFxService.cs
index ecb90d98..7b9a334a 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/DacFx/DacFxService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/DacFx/DacFxService.cs
@@ -46,18 +46,18 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
         /// <param name="serviceHost"></param>
         public void InitializeService(ServiceHost serviceHost)
         {
-            serviceHost.SetRequestHandler(ExportRequest.Type, this.HandleExportRequest);
-            serviceHost.SetRequestHandler(ImportRequest.Type, this.HandleImportRequest);
-            serviceHost.SetRequestHandler(ExtractRequest.Type, this.HandleExtractRequest);
-            serviceHost.SetRequestHandler(DeployRequest.Type, this.HandleDeployRequest);
-            serviceHost.SetRequestHandler(GenerateDeployScriptRequest.Type, this.HandleGenerateDeployScriptRequest);
-            serviceHost.SetRequestHandler(GenerateDeployPlanRequest.Type, this.HandleGenerateDeployPlanRequest);
-            serviceHost.SetRequestHandler(GetOptionsFromProfileRequest.Type, this.HandleGetOptionsFromProfileRequest);
-            serviceHost.SetRequestHandler(ValidateStreamingJobRequest.Type, this.HandleValidateStreamingJobRequest);
-            serviceHost.SetRequestHandler(GetDefaultPublishOptionsRequest.Type, this.HandleGetDefaultPublishOptionsRequest);
-            serviceHost.SetRequestHandler(ParseTSqlScriptRequest.Type, this.HandleParseTSqlScriptRequest);
-            serviceHost.SetRequestHandler(GenerateTSqlModelRequest.Type, this.HandleGenerateTSqlModelRequest);
-            serviceHost.SetRequestHandler(GetObjectsFromTSqlModelRequest.Type, this.HandleGetObjectsFromTSqlModelRequest);
+            serviceHost.SetRequestHandler(ExportRequest.Type, this.HandleExportRequest, true);
+            serviceHost.SetRequestHandler(ImportRequest.Type, this.HandleImportRequest, true);
+            serviceHost.SetRequestHandler(ExtractRequest.Type, this.HandleExtractRequest, true);
+            serviceHost.SetRequestHandler(DeployRequest.Type, this.HandleDeployRequest, true);
+            serviceHost.SetRequestHandler(GenerateDeployScriptRequest.Type, this.HandleGenerateDeployScriptRequest, true);
+            serviceHost.SetRequestHandler(GenerateDeployPlanRequest.Type, this.HandleGenerateDeployPlanRequest, true);
+            serviceHost.SetRequestHandler(GetOptionsFromProfileRequest.Type, this.HandleGetOptionsFromProfileRequest, true);
+            serviceHost.SetRequestHandler(ValidateStreamingJobRequest.Type, this.HandleValidateStreamingJobRequest, true);
+            serviceHost.SetRequestHandler(GetDefaultPublishOptionsRequest.Type, this.HandleGetDefaultPublishOptionsRequest, true);
+            serviceHost.SetRequestHandler(ParseTSqlScriptRequest.Type, this.HandleParseTSqlScriptRequest, true);
+            serviceHost.SetRequestHandler(GenerateTSqlModelRequest.Type, this.HandleGenerateTSqlModelRequest, true);
+            serviceHost.SetRequestHandler(GetObjectsFromTSqlModelRequest.Type, this.HandleGetObjectsFromTSqlModelRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/DisasterRecoveryService.cs b/src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/DisasterRecoveryService.cs
index cd878255..be5db0b8 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/DisasterRecoveryService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/DisasterRecoveryService.cs
@@ -96,22 +96,22 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
         public void InitializeService(IProtocolEndpoint serviceHost)
         {
             // Get database info
-            serviceHost.SetRequestHandler(BackupConfigInfoRequest.Type, HandleBackupConfigInfoRequest);
+            serviceHost.SetRequestHandler(BackupConfigInfoRequest.Type, HandleBackupConfigInfoRequest, true);
 
             // Create backup
-            serviceHost.SetRequestHandler(BackupRequest.Type, HandleBackupRequest);
+            serviceHost.SetRequestHandler(BackupRequest.Type, HandleBackupRequest, true);
 
             // Create restore task
-            serviceHost.SetRequestHandler(RestoreRequest.Type, HandleRestoreRequest);
+            serviceHost.SetRequestHandler(RestoreRequest.Type, HandleRestoreRequest, true);
 
             // Create restore plan
-            serviceHost.SetRequestHandler(RestorePlanRequest.Type, HandleRestorePlanRequest);
+            serviceHost.SetRequestHandler(RestorePlanRequest.Type, HandleRestorePlanRequest, true);
 
             // Cancel restore plan
-            serviceHost.SetRequestHandler(CancelRestorePlanRequest.Type, HandleCancelRestorePlanRequest);
+            serviceHost.SetRequestHandler(CancelRestorePlanRequest.Type, HandleCancelRestorePlanRequest, true);
 
             // Create restore config
-            serviceHost.SetRequestHandler(RestoreConfigInfoRequest.Type, HandleRestoreConfigInfoRequest);
+            serviceHost.SetRequestHandler(RestoreConfigInfoRequest.Type, HandleRestoreConfigInfoRequest, true);
 
             // Register file path validation callbacks
             FileBrowserServiceInstance.RegisterValidatePathsCallback(FileValidationServiceConstants.Backup, DisasterRecoveryFileValidator.ValidatePaths);
diff --git a/src/Microsoft.SqlTools.ServiceLayer/EditData/EditDataService.cs b/src/Microsoft.SqlTools.ServiceLayer/EditData/EditDataService.cs
index e935cf43..a28ac29e 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/EditData/EditDataService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/EditData/EditDataService.cs
@@ -75,15 +75,15 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData
         public void InitializeService(ServiceHost serviceHost)
         {
             // Register handlers for requests
-            serviceHost.SetRequestHandler(EditCreateRowRequest.Type, HandleCreateRowRequest);
-            serviceHost.SetRequestHandler(EditDeleteRowRequest.Type, HandleDeleteRowRequest);
-            serviceHost.SetRequestHandler(EditDisposeRequest.Type, HandleDisposeRequest);
-            serviceHost.SetRequestHandler(EditInitializeRequest.Type, HandleInitializeRequest);
-            serviceHost.SetRequestHandler(EditRevertCellRequest.Type, HandleRevertCellRequest);
-            serviceHost.SetRequestHandler(EditRevertRowRequest.Type, HandleRevertRowRequest);
-            serviceHost.SetRequestHandler(EditSubsetRequest.Type, HandleSubsetRequest);
-            serviceHost.SetRequestHandler(EditUpdateCellRequest.Type, HandleUpdateCellRequest);
-            serviceHost.SetRequestHandler(EditCommitRequest.Type, HandleCommitRequest);
+            serviceHost.SetRequestHandler(EditCreateRowRequest.Type, HandleCreateRowRequest, true);
+            serviceHost.SetRequestHandler(EditDeleteRowRequest.Type, HandleDeleteRowRequest, true);
+            serviceHost.SetRequestHandler(EditDisposeRequest.Type, HandleDisposeRequest, true);
+            serviceHost.SetRequestHandler(EditInitializeRequest.Type, HandleInitializeRequest, true);
+            serviceHost.SetRequestHandler(EditRevertCellRequest.Type, HandleRevertCellRequest, true);
+            serviceHost.SetRequestHandler(EditRevertRowRequest.Type, HandleRevertRowRequest, true);
+            serviceHost.SetRequestHandler(EditSubsetRequest.Type, HandleSubsetRequest, true);
+            serviceHost.SetRequestHandler(EditUpdateCellRequest.Type, HandleUpdateCellRequest, true);
+            serviceHost.SetRequestHandler(EditCommitRequest.Type, HandleCommitRequest, true);
         }
 
         #region Request Handlers
diff --git a/src/Microsoft.SqlTools.ServiceLayer/ExecutionPlan/ExecutionPlanService.cs b/src/Microsoft.SqlTools.ServiceLayer/ExecutionPlan/ExecutionPlanService.cs
index aba8e3f5..eb9880ea 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/ExecutionPlan/ExecutionPlanService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/ExecutionPlan/ExecutionPlanService.cs
@@ -49,8 +49,8 @@ namespace Microsoft.SqlTools.ServiceLayer.ExecutionPlan
         public void InitializeService(ServiceHost serviceHost)
         {
             ServiceHost = serviceHost;
-            ServiceHost.SetRequestHandler(GetExecutionPlanRequest.Type, HandleGetExecutionPlan);
-            ServiceHost.SetRequestHandler(ExecutionPlanComparisonRequest.Type, HandleExecutionPlanComparisonRequest);
+            ServiceHost.SetRequestHandler(GetExecutionPlanRequest.Type, HandleGetExecutionPlan, true);
+            ServiceHost.SetRequestHandler(ExecutionPlanComparisonRequest.Type, HandleExecutionPlanComparisonRequest, true);
         }
 
         private async Task HandleGetExecutionPlan(GetExecutionPlanParams requestParams, RequestContext<GetExecutionPlanResult> requestContext)
diff --git a/src/Microsoft.SqlTools.ServiceLayer/FileBrowser/FileBrowserService.cs b/src/Microsoft.SqlTools.ServiceLayer/FileBrowser/FileBrowserService.cs
index 5994ddd1..b5cc8763 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/FileBrowser/FileBrowserService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/FileBrowser/FileBrowserService.cs
@@ -73,16 +73,16 @@ namespace Microsoft.SqlTools.ServiceLayer.FileBrowser
         public void InitializeService(ServiceHost serviceHost)
         {
             // Open a file browser
-            serviceHost.SetRequestHandler(FileBrowserOpenRequest.Type, HandleFileBrowserOpenRequest);
+            serviceHost.SetRequestHandler(FileBrowserOpenRequest.Type, HandleFileBrowserOpenRequest, true);
 
             // Expand a folder node
-            serviceHost.SetRequestHandler(FileBrowserExpandRequest.Type, HandleFileBrowserExpandRequest);
+            serviceHost.SetRequestHandler(FileBrowserExpandRequest.Type, HandleFileBrowserExpandRequest, true);
 
             // Validate the selected files
-            serviceHost.SetRequestHandler(FileBrowserValidateRequest.Type, HandleFileBrowserValidateRequest);
+            serviceHost.SetRequestHandler(FileBrowserValidateRequest.Type, HandleFileBrowserValidateRequest, true);
 
             // Close the file browser
-            serviceHost.SetRequestHandler(FileBrowserCloseRequest.Type, HandleFileBrowserCloseRequest);
+            serviceHost.SetRequestHandler(FileBrowserCloseRequest.Type, HandleFileBrowserCloseRequest, true);
         }
 
         #region request handlers
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Formatter/TSqlFormatterService.cs b/src/Microsoft.SqlTools.ServiceLayer/Formatter/TSqlFormatterService.cs
index 23c60c08..eff525e5 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Formatter/TSqlFormatterService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Formatter/TSqlFormatterService.cs
@@ -42,8 +42,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Formatter
         public override void InitializeService(IProtocolEndpoint serviceHost)
         {
             Logger.Write(TraceEventType.Verbose, "TSqlFormatter initialized");
-            serviceHost.SetRequestHandler(DocumentFormattingRequest.Type, HandleDocFormatRequest);
-            serviceHost.SetRequestHandler(DocumentRangeFormattingRequest.Type, HandleDocRangeFormatRequest);
+            serviceHost.SetRequestHandler(DocumentFormattingRequest.Type, HandleDocFormatRequest, true);
+            serviceHost.SetRequestHandler(DocumentRangeFormattingRequest.Type, HandleDocRangeFormatRequest, true);
             WorkspaceService?.RegisterConfigChangeCallback(HandleDidChangeConfigurationNotification);
         }
 
diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageExtensibility/ExternalLanguageService.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageExtensibility/ExternalLanguageService.cs
index 5763466b..4c15c676 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/LanguageExtensibility/ExternalLanguageService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageExtensibility/ExternalLanguageService.cs
@@ -60,10 +60,10 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageExtensibility
 
         public void InitializeService(ServiceHost serviceHost)
         {
-            serviceHost.SetRequestHandler(ExternalLanguageStatusRequest.Type, this.HandleExternalLanguageStatusRequest);
-            serviceHost.SetRequestHandler(ExternalLanguageListRequest.Type, this.HandleExternalLanguageListRequest);
-            serviceHost.SetRequestHandler(ExternalLanguageDeleteRequest.Type, this.HandleExternalLanguageDeleteRequest);
-            serviceHost.SetRequestHandler(ExternalLanguageUpdateRequest.Type, this.HandleExternalLanguageUpdateRequest);
+            serviceHost.SetRequestHandler(ExternalLanguageStatusRequest.Type, this.HandleExternalLanguageStatusRequest, true);
+            serviceHost.SetRequestHandler(ExternalLanguageListRequest.Type, this.HandleExternalLanguageListRequest, true);
+            serviceHost.SetRequestHandler(ExternalLanguageDeleteRequest.Type, this.HandleExternalLanguageDeleteRequest, true);
+            serviceHost.SetRequestHandler(ExternalLanguageUpdateRequest.Type, this.HandleExternalLanguageUpdateRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs
index 30df39ea..b3215de2 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs
@@ -252,6 +252,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
             // serviceHost.SetRequestHandler(ReferencesRequest.Type, HandleReferencesRequest);
             // serviceHost.SetRequestHandler(DocumentHighlightRequest.Type, HandleDocumentHighlightRequest);
 
+            // Not enabling parallel processing for LanguageService as message order might matter.
             serviceHost.SetRequestHandler(SignatureHelpRequest.Type, HandleSignatureHelpRequest);
             serviceHost.SetRequestHandler(CompletionResolveRequest.Type, HandleCompletionResolveRequest);
             serviceHost.SetRequestHandler(HoverRequest.Type, HandleHoverRequest);
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Metadata/MetadataService.cs b/src/Microsoft.SqlTools.ServiceLayer/Metadata/MetadataService.cs
index 4fac243b..92e23bda 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Metadata/MetadataService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Metadata/MetadataService.cs
@@ -50,9 +50,9 @@ namespace Microsoft.SqlTools.ServiceLayer.Metadata
         /// <param name="context"></param>
         public void InitializeService(ServiceHost serviceHost)
         {
-            serviceHost.SetRequestHandler(MetadataListRequest.Type, HandleMetadataListRequest);
-            serviceHost.SetRequestHandler(TableMetadataRequest.Type, HandleGetTableRequest);
-            serviceHost.SetRequestHandler(ViewMetadataRequest.Type, HandleGetViewRequest);
+            serviceHost.SetRequestHandler(MetadataListRequest.Type, HandleMetadataListRequest, true);
+            serviceHost.SetRequestHandler(TableMetadataRequest.Type, HandleGetTableRequest, true);
+            serviceHost.SetRequestHandler(ViewMetadataRequest.Type, HandleGetViewRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Migration/MigrationService.cs b/src/Microsoft.SqlTools.ServiceLayer/Migration/MigrationService.cs
index 1afb7fcd..4f6c1f1b 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Migration/MigrationService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Migration/MigrationService.cs
@@ -121,16 +121,16 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
         public void InitializeService(ServiceHost serviceHost)
         {
             this.ServiceHost = serviceHost;
-            this.ServiceHost.SetRequestHandler(MigrationAssessmentsRequest.Type, HandleMigrationAssessmentsRequest);
-            this.ServiceHost.SetRequestHandler(StartPerfDataCollectionRequest.Type, HandleStartPerfDataCollectionRequest);
-            this.ServiceHost.SetRequestHandler(StopPerfDataCollectionRequest.Type, HandleStopPerfDataCollectionRequest);
-            this.ServiceHost.SetRequestHandler(RefreshPerfDataCollectionRequest.Type, HandleRefreshPerfDataCollectionRequest);
-            this.ServiceHost.SetRequestHandler(GetSkuRecommendationsRequest.Type, HandleGetSkuRecommendationsRequest);
-            this.ServiceHost.SetRequestHandler(StartLoginMigrationRequest.Type, HandleStartLoginMigration);
-            this.ServiceHost.SetRequestHandler(ValidateLoginMigrationRequest.Type, HandleValidateLoginMigration);
-            this.ServiceHost.SetRequestHandler(MigrateLoginsRequest.Type, HandleMigrateLogins);
-            this.ServiceHost.SetRequestHandler(EstablishUserMappingRequest.Type, HandleEstablishUserMapping);
-            this.ServiceHost.SetRequestHandler(MigrateServerRolesAndSetPermissionsRequest.Type, HandleMigrateServerRolesAndSetPermissions);
+            this.ServiceHost.SetRequestHandler(MigrationAssessmentsRequest.Type, HandleMigrationAssessmentsRequest, true);
+            this.ServiceHost.SetRequestHandler(StartPerfDataCollectionRequest.Type, HandleStartPerfDataCollectionRequest, true);
+            this.ServiceHost.SetRequestHandler(StopPerfDataCollectionRequest.Type, HandleStopPerfDataCollectionRequest, true);
+            this.ServiceHost.SetRequestHandler(RefreshPerfDataCollectionRequest.Type, HandleRefreshPerfDataCollectionRequest, true);
+            this.ServiceHost.SetRequestHandler(GetSkuRecommendationsRequest.Type, HandleGetSkuRecommendationsRequest, true);
+            this.ServiceHost.SetRequestHandler(StartLoginMigrationRequest.Type, HandleStartLoginMigration, true);
+            this.ServiceHost.SetRequestHandler(ValidateLoginMigrationRequest.Type, HandleValidateLoginMigration, true);
+            this.ServiceHost.SetRequestHandler(MigrateLoginsRequest.Type, HandleMigrateLogins, true);
+            this.ServiceHost.SetRequestHandler(EstablishUserMappingRequest.Type, HandleEstablishUserMapping, true);
+            this.ServiceHost.SetRequestHandler(MigrateServerRolesAndSetPermissionsRequest.Type, HandleMigrateServerRolesAndSetPermissions, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/ModelManagement/ModelManagementService.cs b/src/Microsoft.SqlTools.ServiceLayer/ModelManagement/ModelManagementService.cs
index 4ceec814..7d77d07a 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/ModelManagement/ModelManagementService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/ModelManagement/ModelManagementService.cs
@@ -62,13 +62,13 @@ namespace Microsoft.SqlTools.ServiceLayer.ModelManagement
 
         public void InitializeService(ServiceHost serviceHost)
         {
-            serviceHost.SetRequestHandler(ImportModelRequest.Type, this.HandleModelImportRequest);
-            serviceHost.SetRequestHandler(ConfigureModelTableRequest.Type, this.HandleConfigureModelTableRequest);
-            serviceHost.SetRequestHandler(DeleteModelRequest.Type, this.HandleDeleteModelRequest);
-            serviceHost.SetRequestHandler(DownloadModelRequest.Type, this.HandleDownloadModelRequest);
-            serviceHost.SetRequestHandler(GetModelsRequest.Type, this.HandleGetModelsRequest);
-            serviceHost.SetRequestHandler(UpdateModelRequest.Type, this.HandleUpdateModelRequest);
-            serviceHost.SetRequestHandler(VerifyModelTableRequest.Type, this.HandleVerifyModelTableRequest);
+            serviceHost.SetRequestHandler(ImportModelRequest.Type, this.HandleModelImportRequest, true);
+            serviceHost.SetRequestHandler(ConfigureModelTableRequest.Type, this.HandleConfigureModelTableRequest, true);
+            serviceHost.SetRequestHandler(DeleteModelRequest.Type, this.HandleDeleteModelRequest, true);
+            serviceHost.SetRequestHandler(DownloadModelRequest.Type, this.HandleDownloadModelRequest, true);
+            serviceHost.SetRequestHandler(GetModelsRequest.Type, this.HandleGetModelsRequest, true);
+            serviceHost.SetRequestHandler(UpdateModelRequest.Type, this.HandleUpdateModelRequest, true);
+            serviceHost.SetRequestHandler(VerifyModelTableRequest.Type, this.HandleVerifyModelTableRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/NotebookConvert/NotebookConvertService.cs b/src/Microsoft.SqlTools.ServiceLayer/NotebookConvert/NotebookConvertService.cs
index cbc72119..0cf417c5 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/NotebookConvert/NotebookConvertService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/NotebookConvert/NotebookConvertService.cs
@@ -66,8 +66,8 @@ namespace Microsoft.SqlTools.ServiceLayer.NotebookConvert
         {
             this.ServiceHost = serviceHost;
 
-            this.ServiceHost.SetRequestHandler(ConvertNotebookToSqlRequest.Type, HandleConvertNotebookToSqlRequest);
-            this.ServiceHost.SetRequestHandler(ConvertSqlToNotebookRequest.Type, HandleConvertSqlToNotebookRequest);
+            this.ServiceHost.SetRequestHandler(ConvertNotebookToSqlRequest.Type, HandleConvertNotebookToSqlRequest, true);
+            this.ServiceHost.SetRequestHandler(ConvertSqlToNotebookRequest.Type, HandleConvertSqlToNotebookRequest, true);
 
 
         }
diff --git a/src/Microsoft.SqlTools.ServiceLayer/ObjectExplorer/ObjectExplorerService.cs b/src/Microsoft.SqlTools.ServiceLayer/ObjectExplorer/ObjectExplorerService.cs
index 678df5cc..00da316c 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/ObjectExplorer/ObjectExplorerService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/ObjectExplorer/ObjectExplorerService.cs
@@ -128,6 +128,7 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
 
             this.ConnectedBindingQueue.OnUnhandledException += OnUnhandledException;
 
+            // Not enabling parallel processing for OEService as it might cause OE to hang.
             // Register handlers for requests
             serviceHost.SetRequestHandler(CreateSessionRequest.Type, HandleCreateSessionRequest);
             serviceHost.SetRequestHandler(ExpandRequest.Type, HandleExpandRequest);
diff --git a/src/Microsoft.SqlTools.ServiceLayer/ObjectManagement/ObjectManagementService.cs b/src/Microsoft.SqlTools.ServiceLayer/ObjectManagement/ObjectManagementService.cs
index 0fd44f9d..fb36589a 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/ObjectManagement/ObjectManagementService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/ObjectManagement/ObjectManagementService.cs
@@ -46,7 +46,7 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectManagement
         public void InitializeService(IProtocolEndpoint serviceHost)
         {
             this.serviceHost = serviceHost;
-            this.serviceHost.SetRequestHandler(RenameRequest.Type, HandleRenameRequest);
+            this.serviceHost.SetRequestHandler(RenameRequest.Type, HandleRenameRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Profiler/ProfilerService.cs b/src/Microsoft.SqlTools.ServiceLayer/Profiler/ProfilerService.cs
index 6a345da2..56d1b9c6 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Profiler/ProfilerService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Profiler/ProfilerService.cs
@@ -97,12 +97,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Profiler
         public void InitializeService(ServiceHost serviceHost)
         {
             this.ServiceHost = serviceHost;
-            this.ServiceHost.SetRequestHandler(CreateXEventSessionRequest.Type, HandleCreateXEventSessionRequest);
-            this.ServiceHost.SetRequestHandler(StartProfilingRequest.Type, HandleStartProfilingRequest);
-            this.ServiceHost.SetRequestHandler(StopProfilingRequest.Type, HandleStopProfilingRequest);
-            this.ServiceHost.SetRequestHandler(PauseProfilingRequest.Type, HandlePauseProfilingRequest);
-            this.ServiceHost.SetRequestHandler(GetXEventSessionsRequest.Type, HandleGetXEventSessionsRequest);
-            this.ServiceHost.SetRequestHandler(DisconnectSessionRequest.Type, HandleDisconnectSessionRequest);
+            this.ServiceHost.SetRequestHandler(CreateXEventSessionRequest.Type, HandleCreateXEventSessionRequest, true);
+            this.ServiceHost.SetRequestHandler(StartProfilingRequest.Type, HandleStartProfilingRequest, true);
+            this.ServiceHost.SetRequestHandler(StopProfilingRequest.Type, HandleStopProfilingRequest, true);
+            this.ServiceHost.SetRequestHandler(PauseProfilingRequest.Type, HandlePauseProfilingRequest, true);
+            this.ServiceHost.SetRequestHandler(GetXEventSessionsRequest.Type, HandleGetXEventSessionsRequest, true);
+            this.ServiceHost.SetRequestHandler(DisconnectSessionRequest.Type, HandleDisconnectSessionRequest, true);
 
             this.SessionMonitor.AddSessionListener(this);
         }
diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs
index 84c495a9..3b9ae89c 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs
@@ -170,21 +170,21 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
         public void InitializeService(ServiceHost serviceHost)
         {
             // Register handlers for requests
-            serviceHost.SetRequestHandler(ExecuteDocumentSelectionRequest.Type, HandleExecuteRequest);
-            serviceHost.SetRequestHandler(ExecuteDocumentStatementRequest.Type, HandleExecuteRequest);
-            serviceHost.SetRequestHandler(ExecuteStringRequest.Type, HandleExecuteRequest);
-            serviceHost.SetRequestHandler(SubsetRequest.Type, HandleResultSubsetRequest);
-            serviceHost.SetRequestHandler(QueryDisposeRequest.Type, HandleDisposeRequest);
-            serviceHost.SetRequestHandler(QueryCancelRequest.Type, HandleCancelRequest);
+            serviceHost.SetRequestHandler(ExecuteDocumentSelectionRequest.Type, HandleExecuteRequest, true);
+            serviceHost.SetRequestHandler(ExecuteDocumentStatementRequest.Type, HandleExecuteRequest, true);
+            serviceHost.SetRequestHandler(ExecuteStringRequest.Type, HandleExecuteRequest, true);
+            serviceHost.SetRequestHandler(SubsetRequest.Type, HandleResultSubsetRequest, true);
+            serviceHost.SetRequestHandler(QueryDisposeRequest.Type, HandleDisposeRequest, true);
+            serviceHost.SetRequestHandler(QueryCancelRequest.Type, HandleCancelRequest, true);
             serviceHost.SetEventHandler(ConnectionUriChangedNotification.Type, HandleConnectionUriChangedNotification);
-            serviceHost.SetRequestHandler(SaveResultsAsCsvRequest.Type, HandleSaveResultsAsCsvRequest);
-            serviceHost.SetRequestHandler(SaveResultsAsExcelRequest.Type, HandleSaveResultsAsExcelRequest);
-            serviceHost.SetRequestHandler(SaveResultsAsJsonRequest.Type, HandleSaveResultsAsJsonRequest);
-            serviceHost.SetRequestHandler(SaveResultsAsMarkdownRequest.Type, this.HandleSaveResultsAsMarkdownRequest);
-            serviceHost.SetRequestHandler(SaveResultsAsXmlRequest.Type, HandleSaveResultsAsXmlRequest);
-            serviceHost.SetRequestHandler(QueryExecutionPlanRequest.Type, HandleExecutionPlanRequest);
-            serviceHost.SetRequestHandler(SimpleExecuteRequest.Type, HandleSimpleExecuteRequest);
-            serviceHost.SetRequestHandler(QueryExecutionOptionsRequest.Type, HandleQueryExecutionOptionsRequest);
+            serviceHost.SetRequestHandler(SaveResultsAsCsvRequest.Type, HandleSaveResultsAsCsvRequest, true);
+            serviceHost.SetRequestHandler(SaveResultsAsExcelRequest.Type, HandleSaveResultsAsExcelRequest, true);
+            serviceHost.SetRequestHandler(SaveResultsAsJsonRequest.Type, HandleSaveResultsAsJsonRequest, true);
+            serviceHost.SetRequestHandler(SaveResultsAsMarkdownRequest.Type, this.HandleSaveResultsAsMarkdownRequest, true);
+            serviceHost.SetRequestHandler(SaveResultsAsXmlRequest.Type, HandleSaveResultsAsXmlRequest, true);
+            serviceHost.SetRequestHandler(QueryExecutionPlanRequest.Type, HandleExecutionPlanRequest, true);
+            serviceHost.SetRequestHandler(SimpleExecuteRequest.Type, HandleSimpleExecuteRequest, true);
+            serviceHost.SetRequestHandler(QueryExecutionOptionsRequest.Type, HandleQueryExecutionOptionsRequest, true);
 
             // Register the file open update handler
             WorkspaceService<SqlToolsSettings>.Instance.RegisterTextDocCloseCallback(HandleDidCloseTextDocumentNotification);
diff --git a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SerializationService.cs b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SerializationService.cs
index 56390cee..1622b491 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SerializationService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SerializationService.cs
@@ -34,8 +34,8 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
         public override void InitializeService(IProtocolEndpoint serviceHost)
         {
             Logger.Write(TraceEventType.Verbose, "SerializationService initialized");
-            serviceHost.SetRequestHandler(SerializeStartRequest.Type, HandleSerializeStartRequest);
-            serviceHost.SetRequestHandler(SerializeContinueRequest.Type, HandleSerializeContinueRequest);
+            serviceHost.SetRequestHandler(SerializeStartRequest.Type, HandleSerializeStartRequest, true);
+            serviceHost.SetRequestHandler(SerializeContinueRequest.Type, HandleSerializeContinueRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaCompareService.cs b/src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaCompareService.cs
index a7290ee7..043d1c17 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaCompareService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaCompareService.cs
@@ -48,15 +48,15 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
         /// <param name="serviceHost"></param>
         public void InitializeService(ServiceHost serviceHost)
         {
-            serviceHost.SetRequestHandler(SchemaCompareRequest.Type, this.HandleSchemaCompareRequest);
-            serviceHost.SetRequestHandler(SchemaCompareCancellationRequest.Type, this.HandleSchemaCompareCancelRequest);
-            serviceHost.SetRequestHandler(SchemaCompareGenerateScriptRequest.Type, this.HandleSchemaCompareGenerateScriptRequest);
-            serviceHost.SetRequestHandler(SchemaComparePublishDatabaseChangesRequest.Type, this.HandleSchemaComparePublishDatabaseChangesRequest);
-            serviceHost.SetRequestHandler(SchemaComparePublishProjectChangesRequest.Type, this.HandleSchemaComparePublishProjectChangesRequest);
-            serviceHost.SetRequestHandler(SchemaCompareIncludeExcludeNodeRequest.Type, this.HandleSchemaCompareIncludeExcludeNodeRequest);
-            serviceHost.SetRequestHandler(SchemaCompareGetDefaultOptionsRequest.Type, this.HandleSchemaCompareGetDefaultOptionsRequest);
-            serviceHost.SetRequestHandler(SchemaCompareOpenScmpRequest.Type, this.HandleSchemaCompareOpenScmpRequest);
-            serviceHost.SetRequestHandler(SchemaCompareSaveScmpRequest.Type, this.HandleSchemaCompareSaveScmpRequest);
+            serviceHost.SetRequestHandler(SchemaCompareRequest.Type, this.HandleSchemaCompareRequest, true);
+            serviceHost.SetRequestHandler(SchemaCompareCancellationRequest.Type, this.HandleSchemaCompareCancelRequest, true);
+            serviceHost.SetRequestHandler(SchemaCompareGenerateScriptRequest.Type, this.HandleSchemaCompareGenerateScriptRequest, true);
+            serviceHost.SetRequestHandler(SchemaComparePublishDatabaseChangesRequest.Type, this.HandleSchemaComparePublishDatabaseChangesRequest, true);
+            serviceHost.SetRequestHandler(SchemaComparePublishProjectChangesRequest.Type, this.HandleSchemaComparePublishProjectChangesRequest, true);
+            serviceHost.SetRequestHandler(SchemaCompareIncludeExcludeNodeRequest.Type, this.HandleSchemaCompareIncludeExcludeNodeRequest, true);
+            serviceHost.SetRequestHandler(SchemaCompareGetDefaultOptionsRequest.Type, this.HandleSchemaCompareGetDefaultOptionsRequest, true);
+            serviceHost.SetRequestHandler(SchemaCompareOpenScmpRequest.Type, this.HandleSchemaCompareOpenScmpRequest, true);
+            serviceHost.SetRequestHandler(SchemaCompareSaveScmpRequest.Type, this.HandleSchemaCompareSaveScmpRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Scripting/ScriptingService.cs b/src/Microsoft.SqlTools.ServiceLayer/Scripting/ScriptingService.cs
index 58d332df..e4ba93cf 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Scripting/ScriptingService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Scripting/ScriptingService.cs
@@ -65,9 +65,9 @@ namespace Microsoft.SqlTools.ServiceLayer.Scripting
         /// <param name="context"></param>
         public void InitializeService(ServiceHost serviceHost)
         {
-            serviceHost.SetRequestHandler(ScriptingRequest.Type, this.HandleScriptExecuteRequest);
-            serviceHost.SetRequestHandler(ScriptingCancelRequest.Type, this.HandleScriptCancelRequest);
-            serviceHost.SetRequestHandler(ScriptingListObjectsRequest.Type, this.HandleListObjectsRequest);
+            serviceHost.SetRequestHandler(ScriptingRequest.Type, this.HandleScriptExecuteRequest, true);
+            serviceHost.SetRequestHandler(ScriptingCancelRequest.Type, this.HandleScriptCancelRequest, true);
+            serviceHost.SetRequestHandler(ScriptingListObjectsRequest.Type, this.HandleListObjectsRequest, true);
 
             // Register handler for shutdown event
             serviceHost.RegisterShutdownTask((shutdownParams, requestContext) =>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Security/SecurityService.cs b/src/Microsoft.SqlTools.ServiceLayer/Security/SecurityService.cs
index dec38ad2..e83edc4b 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Security/SecurityService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Security/SecurityService.cs
@@ -75,10 +75,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Security
             this.ServiceHost = serviceHost;
 
             // Credential request handlers
-            this.ServiceHost.SetRequestHandler(CreateCredentialRequest.Type, HandleCreateCredentialRequest);
-            this.ServiceHost.SetRequestHandler(UpdateCredentialRequest.Type, HandleUpdateCredentialRequest);
-            this.ServiceHost.SetRequestHandler(DeleteCredentialRequest.Type, HandleDeleteCredentialRequest);
-            this.ServiceHost.SetRequestHandler(GetCredentialsRequest.Type, HandleGetCredentialsRequest);
+            this.ServiceHost.SetRequestHandler(CreateCredentialRequest.Type, HandleCreateCredentialRequest, true);
+            this.ServiceHost.SetRequestHandler(UpdateCredentialRequest.Type, HandleUpdateCredentialRequest, true);
+            this.ServiceHost.SetRequestHandler(DeleteCredentialRequest.Type, HandleDeleteCredentialRequest, true);
+            this.ServiceHost.SetRequestHandler(GetCredentialsRequest.Type, HandleGetCredentialsRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/ServerConfigService.cs b/src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/ServerConfigService.cs
index e0ec0ec4..be3a907f 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/ServerConfigService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/ServerConfigService.cs
@@ -49,9 +49,9 @@ namespace Microsoft.SqlTools.ServiceLayer.ServerConfigurations
 
         public void InitializeService(ServiceHost serviceHost)
         {
-            serviceHost.SetRequestHandler(ServerConfigViewRequest.Type, this.HandleServerConfigViewRequest);
-            serviceHost.SetRequestHandler(ServerConfigUpdateRequest.Type, this.HandleServerConfigUpdateRequest);
-            serviceHost.SetRequestHandler(ServerConfigListRequest.Type, this.HandleServerConfigListRequest);
+            serviceHost.SetRequestHandler(ServerConfigViewRequest.Type, this.HandleServerConfigViewRequest, true);
+            serviceHost.SetRequestHandler(ServerConfigUpdateRequest.Type, this.HandleServerConfigUpdateRequest, true);
+            serviceHost.SetRequestHandler(ServerConfigListRequest.Type, this.HandleServerConfigListRequest, true);
         }
 
         /// <summary>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/SqlAssessment/SqlAssessmentService.cs b/src/Microsoft.SqlTools.ServiceLayer/SqlAssessment/SqlAssessmentService.cs
index f5bc5d82..d6424a36 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/SqlAssessment/SqlAssessmentService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/SqlAssessment/SqlAssessmentService.cs
@@ -102,9 +102,9 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlAssessment
         public void InitializeService(ServiceHost serviceHost)
         {
             // Register handlers for requests
-            serviceHost.SetRequestHandler(InvokeRequest.Type, HandleInvokeRequest);
-            serviceHost.SetRequestHandler(GetAssessmentItemsRequest.Type, HandleGetAssessmentItemsRequest);
-            serviceHost.SetRequestHandler(GenerateScriptRequest.Type, HandleGenerateScriptRequest);
+            serviceHost.SetRequestHandler(InvokeRequest.Type, HandleInvokeRequest, true);
+            serviceHost.SetRequestHandler(GetAssessmentItemsRequest.Type, HandleGetAssessmentItemsRequest, true);
+            serviceHost.SetRequestHandler(GenerateScriptRequest.Type, HandleGenerateScriptRequest, true);
 
             // Register handler for shutdown event
             serviceHost.RegisterShutdownTask((shutdownParams, requestContext) =>
diff --git a/src/Microsoft.SqlTools.ServiceLayer/TableDesigner/TableDesignerService.cs b/src/Microsoft.SqlTools.ServiceLayer/TableDesigner/TableDesignerService.cs
index fd984918..c8893e56 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/TableDesigner/TableDesignerService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/TableDesigner/TableDesignerService.cs
@@ -58,12 +58,12 @@ namespace Microsoft.SqlTools.ServiceLayer.TableDesigner
         public void InitializeService(ServiceHost serviceHost)
         {
             this.ServiceHost = serviceHost;
-            this.ServiceHost.SetRequestHandler(InitializeTableDesignerRequest.Type, HandleInitializeTableDesignerRequest);
-            this.ServiceHost.SetRequestHandler(ProcessTableDesignerEditRequest.Type, HandleProcessTableDesignerEditRequest);
-            this.ServiceHost.SetRequestHandler(PublishTableChangesRequest.Type, HandlePublishTableChangesRequest);
-            this.ServiceHost.SetRequestHandler(GenerateScriptRequest.Type, HandleGenerateScriptRequest);
-            this.ServiceHost.SetRequestHandler(GeneratePreviewReportRequest.Type, HandleGeneratePreviewReportRequest);
-            this.ServiceHost.SetRequestHandler(DisposeTableDesignerRequest.Type, HandleDisposeTableDesignerRequest);
+            this.ServiceHost.SetRequestHandler(InitializeTableDesignerRequest.Type, HandleInitializeTableDesignerRequest, true);
+            this.ServiceHost.SetRequestHandler(ProcessTableDesignerEditRequest.Type, HandleProcessTableDesignerEditRequest, true);
+            this.ServiceHost.SetRequestHandler(PublishTableChangesRequest.Type, HandlePublishTableChangesRequest, true);
+            this.ServiceHost.SetRequestHandler(GenerateScriptRequest.Type, HandleGenerateScriptRequest, true);
+            this.ServiceHost.SetRequestHandler(GeneratePreviewReportRequest.Type, HandleGeneratePreviewReportRequest, true);
+            this.ServiceHost.SetRequestHandler(DisposeTableDesignerRequest.Type, HandleDisposeTableDesignerRequest, true);
             Workspace.WorkspaceService<SqlToolsSettings>.Instance.RegisterConfigChangeCallback(UpdateSettings);
 
         }
diff --git a/src/Microsoft.SqlTools.ServiceLayer/TaskServices/TaskService.cs b/src/Microsoft.SqlTools.ServiceLayer/TaskServices/TaskService.cs
index 2e52ea9a..e57f0464 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/TaskServices/TaskService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/TaskServices/TaskService.cs
@@ -52,8 +52,8 @@ namespace Microsoft.SqlTools.ServiceLayer.TaskServices
         {
             this.serviceHost = serviceHost;
             Logger.Write(TraceEventType.Verbose, "TaskService initialized");
-            serviceHost.SetRequestHandler(ListTasksRequest.Type, HandleListTasksRequest);
-            serviceHost.SetRequestHandler(CancelTaskRequest.Type, HandleCancelTaskRequest);
+            serviceHost.SetRequestHandler(ListTasksRequest.Type, HandleListTasksRequest, true);
+            serviceHost.SetRequestHandler(CancelTaskRequest.Type, HandleCancelTaskRequest, true);
             TaskManager.TaskAdded += OnTaskAdded;
         }
 
diff --git a/src/Microsoft.SqlTools.ServiceLayer/Workspace/WorkspaceService.cs b/src/Microsoft.SqlTools.ServiceLayer/Workspace/WorkspaceService.cs
index 773803f9..b3d5aacb 100644
--- a/src/Microsoft.SqlTools.ServiceLayer/Workspace/WorkspaceService.cs
+++ b/src/Microsoft.SqlTools.ServiceLayer/Workspace/WorkspaceService.cs
@@ -127,6 +127,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Workspace
             // Create a workspace that will handle state for the session
             Workspace = new Workspace();
 
+            // Not enabling parallel processing for WorkspaceService as it might cause doc out of sync.
             // Register the handlers for when changes to the workspae occur
             serviceHost.SetEventHandler(DidChangeTextDocumentNotification.Type, HandleDidChangeTextDocumentNotification);
             serviceHost.SetEventHandler(DidOpenTextDocumentNotification.Type, HandleDidOpenTextDocumentNotification);
diff --git a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/Messaging/MessageDispatcherTests.cs b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/Messaging/MessageDispatcherTests.cs
index bb748bf9..e1d6e304 100644
--- a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/Messaging/MessageDispatcherTests.cs
+++ b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/Messaging/MessageDispatcherTests.cs
@@ -4,6 +4,8 @@
 //
 
 using System;
+using System.Diagnostics;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.SqlTools.Hosting.Protocol;
 using Microsoft.SqlTools.Hosting.Protocol.Channel;
@@ -84,5 +86,70 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Messaging
                 Assert.True(handlerCalled);   
             }
         }
+
+        [Test]
+        public void ParallelMessageProcessingTest()
+        {
+            int numOfRequests = 10;
+            int msForEachRequest = 1000;
+            // Without parallel processing, this should take around numOfRequests * msForEachRequest ms to finish.
+            // With parallel process, this should take around 1 * msForEachRequest ms to finish.
+            // The diff should be around (numOfRequests - 1) * msForEachRequest ms.
+            // In order to make this test stable, we loose the assertion by checking the diff against
+            // (numOfRequests  / 2) * msForEachRequest ms, which should for sure pass.
+            Assert.IsTrue(GetTimeToHandleRequests(false, numOfRequests, msForEachRequest) - GetTimeToHandleRequests(true, numOfRequests, msForEachRequest) > msForEachRequest * (numOfRequests / 2));
+        }
+
+
+        /// <summary>
+        /// Gets the time to handle certain amount of requests in ms
+        /// </summary>
+        /// <param name="parallelMessageProcessing">Wheater to enable parallel processing</param>
+        /// <param name="numOfRequests">num of requests to handle</param>
+        /// <param name="msForEachRequest">rough time taken to finish each reqeust in ms</param>
+        /// <returns></returns>
+        private long GetTimeToHandleRequests(bool parallelMessageProcessing, int numOfRequests, int msForEachRequest)
+        {
+            RequestType<int, int> requestType = RequestType<int, int>.Create("test/requestType");
+            var mockChannel = new Mock<ChannelBase>();
+            SemaphoreSlim unfinishedRequestCount = new SemaphoreSlim(numOfRequests);
+            bool okayToEnd = false;
+            mockChannel.Setup(c => c.MessageReader.ReadMessage())
+                .Returns(Task.FromResult(Message.Request("1", "test/requestType", null)));
+            var dispatcher = new MessageDispatcher(mockChannel.Object);
+            dispatcher.ParallelMessageProcessing = parallelMessageProcessing;
+            Stopwatch stopwatch = Stopwatch.StartNew();
+            var handler = async (int _, RequestContext<int> _) =>
+            {
+                // simulate a slow sync call
+                Thread.Sleep(msForEachRequest / 2);
+                // simulate a delay async call
+                await Task.Delay(msForEachRequest / 2);
+                await unfinishedRequestCount.WaitAsync();
+                if (unfinishedRequestCount.CurrentCount == 0)
+                {
+                    // cut off when we reach numOfRequests
+                    stopwatch.Stop();
+                    okayToEnd = true;
+                }
+                await Task.CompletedTask;
+            };
+
+            dispatcher.SetRequestHandler(requestType, handler, false, true);
+            dispatcher.Start();
+
+            while (true)
+            {
+                if (okayToEnd)
+                {
+                    // wait until we finish handling the required amount of requests
+                    break;
+                }
+                Thread.Sleep(1000);
+            }
+
+            dispatcher.Stop();
+            return stopwatch.ElapsedMilliseconds;
+        }
     }
 }
\ No newline at end of file