diff --git a/sample/SampleServer/TextDocumentHandler.cs b/sample/SampleServer/TextDocumentHandler.cs
index 0b0fd54df..24df82dd5 100644
--- a/sample/SampleServer/TextDocumentHandler.cs
+++ b/sample/SampleServer/TextDocumentHandler.cs
@@ -100,9 +100,9 @@ TextDocumentSaveRegistrationOptions IRegistration<TextDocumentSaveRegistrationOp
             };
         }
 
-        public TextDocumentAttributes GetTextDocumentAttributes(DocumentUri uri)
+        public IEnumerable<TextDocumentAttributes> GetTextDocumentAttributes(DocumentUri uri)
         {
-            return new TextDocumentAttributes(uri, "csharp");
+            yield return new TextDocumentAttributes(uri, "csharp");
         }
     }
 
diff --git a/src/JsonRpc.Testing/IRequestSettler.cs b/src/JsonRpc.Testing/IRequestSettler.cs
index df34e935f..9bb02a39b 100644
--- a/src/JsonRpc.Testing/IRequestSettler.cs
+++ b/src/JsonRpc.Testing/IRequestSettler.cs
@@ -5,4 +5,4 @@ public interface IRequestSettler
         void OnStartRequest();
         void OnEndRequest();
     }
-}
+}
\ No newline at end of file
diff --git a/src/JsonRpc/IRequestRouter.cs b/src/JsonRpc/IRequestRouter.cs
index 58f3fedf9..6a3f5da2e 100644
--- a/src/JsonRpc/IRequestRouter.cs
+++ b/src/JsonRpc/IRequestRouter.cs
@@ -1,4 +1,7 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using OmniSharp.Extensions.JsonRpc.Server;
@@ -10,11 +13,38 @@ public interface IRequestRouter
         IServiceProvider ServiceProvider { get; }
     }
 
+    public interface IRequestDescriptor<out TDescriptor> : IEnumerable<TDescriptor>
+    {
+        TDescriptor Default { get; }
+    }
+
+    class RequestDescriptor<TDescriptor> : IRequestDescriptor<TDescriptor>
+    {
+        private IEnumerable<TDescriptor> _descriptors;
+
+        public RequestDescriptor(IEnumerable<TDescriptor> descriptors)
+        {
+            var enumerable = descriptors as TDescriptor[] ?? descriptors.ToArray();
+            _descriptors = enumerable;
+            Default = enumerable.FirstOrDefault();
+        }
+
+        public IEnumerator<TDescriptor> GetEnumerator() => _descriptors.GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable) _descriptors).GetEnumerator();
+
+        public TDescriptor Default { get; }
+    }
+
     public interface IRequestRouter<TDescriptor> : IRequestRouter
     {
-        TDescriptor GetDescriptor(Notification notification);
-        TDescriptor GetDescriptor(Request request);
-        Task RouteNotification(TDescriptor descriptor, Notification notification, CancellationToken token);
-        Task<ErrorResponse> RouteRequest(TDescriptor descriptor, Request request, CancellationToken token);
+        IRequestDescriptor<TDescriptor> GetDescriptor(Notification notification);
+        IRequestDescriptor<TDescriptor> GetDescriptor(Request request);
+        Task RouteNotification(IRequestDescriptor<TDescriptor> descriptors, Notification notification, CancellationToken token);
+        Task<ErrorResponse> RouteRequest(IRequestDescriptor<TDescriptor> descriptors, Request request, CancellationToken token);
+    }
+
+    interface IAggregateResults
+    {
+        object AggregateResults(IEnumerable<object> values);
     }
 }
diff --git a/src/JsonRpc/InputHandler.cs b/src/JsonRpc/InputHandler.cs
index a511e605d..6676e6074 100644
--- a/src/JsonRpc/InputHandler.cs
+++ b/src/JsonRpc/InputHandler.cs
@@ -54,8 +54,8 @@ public class InputHandler : IInputHandler, IDisposable
         private readonly CompositeDisposable _disposable;
         private readonly AsyncSubject<Unit> _inputActive;
 
-        private readonly ConcurrentDictionary<object, (CancellationTokenSource cancellationTokenSource, IHandlerDescriptor descriptor)> _requests =
-            new ConcurrentDictionary<object, (CancellationTokenSource cancellationTokenSource, IHandlerDescriptor descriptor)>();
+        private readonly ConcurrentDictionary<object, (CancellationTokenSource cancellationTokenSource, IRequestDescriptor<IHandlerDescriptor> descriptor)> _requests =
+            new ConcurrentDictionary<object, (CancellationTokenSource cancellationTokenSource, IRequestDescriptor<IHandlerDescriptor> descriptor)>();
 
         private readonly Subject<IObservable<Unit>> _inputQueue;
 
@@ -411,14 +411,14 @@ private void HandleRequest(in ReadOnlySequence<byte> request)
                 {
                     // _logger.LogDebug("Handling Request {Method} {ResponseId}", item.Request.Method, item.Request.Id);
                     var descriptor = _requestRouter.GetDescriptor(item.Request);
-                    if (descriptor is null)
+                    if (descriptor.Default is null)
                     {
                         _logger.LogDebug("Request handler was not found (or not setup) {Method} {ResponseId}", item.Request.Method, item.Request.Id);
                         _outputHandler.Send(new MethodNotFound(item.Request.Id, item.Request.Method));
                         return;
                     }
 
-                    var type = _requestProcessIdentifier.Identify(descriptor);
+                    var type = _requestProcessIdentifier.Identify(descriptor.Default);
                     _scheduler.Add(type, $"{item.Request.Method}:{item.Request.Id}", RouteRequest(descriptor, item.Request));
                 }
 
@@ -446,7 +446,7 @@ private void HandleRequest(in ReadOnlySequence<byte> request)
 
                     // _logger.LogDebug("Handling Request {Method}", item.Notification.Method);
                     var descriptor = _requestRouter.GetDescriptor(item.Notification);
-                    if (descriptor is null)
+                    if (descriptor.Default is null)
                     {
                         _logger.LogDebug("Notification handler was not found (or not setup) {Method}", item.Notification.Method);
                         // TODO: Figure out a good way to send this feedback back.
@@ -454,7 +454,7 @@ private void HandleRequest(in ReadOnlySequence<byte> request)
                         return;
                     }
 
-                    var type = _requestProcessIdentifier.Identify(descriptor);
+                    var type = _requestProcessIdentifier.Identify(descriptor.Default);
                     _scheduler.Add(type, item.Notification.Method, RouteNotification(descriptor, item.Notification));
                 }
 
@@ -465,7 +465,7 @@ private void HandleRequest(in ReadOnlySequence<byte> request)
             }
         }
 
-        private SchedulerDelegate RouteRequest(IHandlerDescriptor descriptor, Request request)
+        private SchedulerDelegate RouteRequest(IRequestDescriptor<IHandlerDescriptor> descriptor, Request request)
         {
             // start request, create cts, etc
             var cts = new CancellationTokenSource();
@@ -521,7 +521,7 @@ private SchedulerDelegate RouteRequest(IHandlerDescriptor descriptor, Request re
                 });
         }
 
-        private SchedulerDelegate RouteNotification(IHandlerDescriptor descriptor, Notification notification)
+        private SchedulerDelegate RouteNotification(IRequestDescriptor<IHandlerDescriptor> descriptor, Notification notification)
         {
             return (contentModifiedToken, scheduler) =>
                     // ITS A RACE!
diff --git a/src/JsonRpc/NotificationHandler.cs b/src/JsonRpc/NotificationHandler.cs
index 31d1262a0..b0bb234c9 100644
--- a/src/JsonRpc/NotificationHandler.cs
+++ b/src/JsonRpc/NotificationHandler.cs
@@ -5,12 +5,12 @@
 
 namespace OmniSharp.Extensions.JsonRpc
 {
-    public static class NotificationHandler
-    {
+    public static class NotificationHandler {
+
         public static DelegatingHandlers.Notification<TParams> For<TParams>(Action<TParams, CancellationToken> handler)
             where TParams : IRequest
         {
-            return new DelegatingHandlers.Notification<TParams>(handler);
+            return new DelegatingHandlers.Notification<TParams>( handler);
         }
 
         public static DelegatingHandlers.Notification<TParams> For<TParams>(Func<TParams, CancellationToken, Task> handler)
@@ -18,7 +18,6 @@ public static DelegatingHandlers.Notification<TParams> For<TParams>(Func<TParams
         {
             return new DelegatingHandlers.Notification<TParams>(handler);
         }
-
         public static DelegatingHandlers.Notification<TParams> For<TParams>(Action<TParams> handler)
             where TParams : IRequest
         {
@@ -31,4 +30,4 @@ public static DelegatingHandlers.Notification<TParams> For<TParams>(Func<TParams
             return new DelegatingHandlers.Notification<TParams>((p, ct) => handler(p));
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/JsonRpc/RequestRouter.cs b/src/JsonRpc/RequestRouter.cs
index 456fa7491..cb18e6aeb 100644
--- a/src/JsonRpc/RequestRouter.cs
+++ b/src/JsonRpc/RequestRouter.cs
@@ -22,17 +22,17 @@ public IDisposable Add(IJsonRpcHandler handler)
             return _collection.Add(handler);
         }
 
-        private IHandlerDescriptor FindDescriptor(IMethodWithParams instance)
+        private IRequestDescriptor<IHandlerDescriptor> FindDescriptor(IMethodWithParams instance)
         {
-            return _collection.FirstOrDefault(x => x.Method == instance.Method);
+            return new RequestDescriptor<IHandlerDescriptor>(_collection.Where(x => x.Method == instance.Method));
         }
 
-        public override IHandlerDescriptor GetDescriptor(Notification notification)
+        public override IRequestDescriptor<IHandlerDescriptor> GetDescriptor(Notification notification)
         {
             return FindDescriptor(notification);
         }
 
-        public override IHandlerDescriptor GetDescriptor(Request request)
+        public override IRequestDescriptor<IHandlerDescriptor> GetDescriptor(Request request)
         {
             return FindDescriptor(request);
         }
diff --git a/src/JsonRpc/RequestRouterBase.cs b/src/JsonRpc/RequestRouterBase.cs
index db0d6ca75..af76ab61b 100644
--- a/src/JsonRpc/RequestRouterBase.cs
+++ b/src/JsonRpc/RequestRouterBase.cs
@@ -10,6 +10,7 @@
 using Microsoft.Extensions.Logging;
 using System.Collections.Generic;
 using System.Linq;
+using OmniSharp.Extensions.JsonRpc.Client;
 
 namespace OmniSharp.Extensions.JsonRpc
 {
@@ -30,42 +31,48 @@ public RequestRouterBase(ISerializer serializer, IServiceProvider serviceProvide
 
         public IServiceProvider ServiceProvider { get; }
 
-        public async Task RouteNotification(TDescriptor descriptor, Notification notification, CancellationToken token)
+        public async Task RouteNotification(IRequestDescriptor<TDescriptor> descriptors, Notification notification, CancellationToken token)
         {
             using var debug = _logger.TimeDebug("Routing Notification {Method}", notification.Method);
             using var _ = _logger.BeginScope(new[] {
                 new KeyValuePair<string, string>("Method", notification.Method),
                 new KeyValuePair<string, string>("Params", notification.Params?.ToString())
             });
-            using var scope = _serviceScopeFactory.CreateScope();
-            var context = scope.ServiceProvider.GetRequiredService<IRequestContext>();
-            context.Descriptor = descriptor;
-            var mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
 
-            if (descriptor.Params is null)
-            {
-                await HandleNotification(mediator, descriptor, EmptyRequest.Instance, token);
-            }
-            else
+            await Task.WhenAll(descriptors.Select(descriptor => InnerRouteNotification(descriptor)));
+
+            async Task InnerRouteNotification(TDescriptor descriptor)
             {
-                _logger.LogDebug("Converting params for Notification {Method} to {Type}", notification.Method, descriptor.Params.FullName);
-                object @params;
-                if (descriptor.IsDelegatingHandler)
+                using var scope = _serviceScopeFactory.CreateScope();
+                var context = scope.ServiceProvider.GetRequiredService<IRequestContext>();
+                context.Descriptor = descriptor;
+                var mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+                if (descriptor.Params is null)
                 {
-                    // new DelegatingRequest();
-                    var o = notification.Params?.ToObject(descriptor.Params.GetGenericArguments()[0], _serializer.JsonSerializer);
-                    @params = Activator.CreateInstance(descriptor.Params, new object[] {o});
+                    await HandleNotification(mediator, descriptor, EmptyRequest.Instance, token);
                 }
                 else
                 {
-                    @params = notification.Params?.ToObject(descriptor.Params, _serializer.JsonSerializer);
+                    _logger.LogDebug("Converting params for Notification {Method} to {Type}", notification.Method, descriptor.Params.FullName);
+                    object @params;
+                    if (descriptor.IsDelegatingHandler)
+                    {
+                        // new DelegatingRequest();
+                        var o = notification.Params?.ToObject(descriptor.Params.GetGenericArguments()[0], _serializer.JsonSerializer);
+                        @params = Activator.CreateInstance(descriptor.Params, new object[] {o});
+                    }
+                    else
+                    {
+                        @params = notification.Params?.ToObject(descriptor.Params, _serializer.JsonSerializer);
+                    }
+
+                    await HandleNotification(mediator, descriptor, @params ?? Activator.CreateInstance(descriptor.Params), token);
                 }
-
-                await HandleNotification(mediator, descriptor, @params ?? Activator.CreateInstance(descriptor.Params), token);
             }
         }
 
-        public virtual async Task<ErrorResponse> RouteRequest(TDescriptor descriptor, Request request, CancellationToken token)
+        public virtual async Task<ErrorResponse> RouteRequest(IRequestDescriptor<TDescriptor> descriptors, Request request, CancellationToken token)
         {
             using var debug = _logger.TimeDebug("Routing Request ({Id}) {Method}", request.Id, request.Method);
             using var _ = _logger.BeginScope(new[] {
@@ -73,7 +80,27 @@ public virtual async Task<ErrorResponse> RouteRequest(TDescriptor descriptor, Re
                 new KeyValuePair<string, string>("Method", request.Method),
                 new KeyValuePair<string, string>("Params", request.Params?.ToString())
             });
-            using var scope = _serviceScopeFactory.CreateScope();
+
+            if (typeof(IAggregateResults).IsAssignableFrom(descriptors.Default.Response))
+            {
+                var responses = await Task.WhenAll(descriptors.Select(InnerRouteRequest));
+                var errorResponse = responses.FirstOrDefault(x => x.IsError);
+                if (errorResponse.IsError) return errorResponse;
+                if (responses.Length == 1)
+                {
+                    return responses[0];
+                }
+
+                if (!(responses[0].Value is OutgoingResponse or)) throw new NotSupportedException("Unsupported response type");
+                if (!(or.Result is IAggregateResults ar)) throw new NotSupportedException("Unsupported result type");
+                return new OutgoingResponse(request.Id, ar.AggregateResults(responses.Skip(1).Select(z => z.Value).OfType<OutgoingResponse>().Select(z => z.Result)), request);
+            }
+
+            return await InnerRouteRequest(descriptors.Default);
+
+            async Task<ErrorResponse> InnerRouteRequest(TDescriptor descriptor)
+            {
+                using var scope = _serviceScopeFactory.CreateScope();
             var context = scope.ServiceProvider.GetRequiredService<IRequestContext>();
             context.Descriptor = descriptor;
             var mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
@@ -132,12 +159,12 @@ public virtual async Task<ErrorResponse> RouteRequest(TDescriptor descriptor, Re
 
                 _logger.LogTrace("Response value was {Type}", responseValue?.GetType().FullName);
             }
-
             return new JsonRpc.Client.OutgoingResponse(request.Id, responseValue, request);
+            }
         }
 
-        public abstract TDescriptor GetDescriptor(Notification notification);
-        public abstract TDescriptor GetDescriptor(Request request);
+        public abstract IRequestDescriptor<TDescriptor> GetDescriptor(Notification notification);
+        public abstract IRequestDescriptor<TDescriptor> GetDescriptor(Request request);
 
         private static readonly MethodInfo SendRequestUnit = typeof(RequestRouterBase<TDescriptor>)
             .GetMethods(BindingFlags.NonPublic | BindingFlags.Static)
diff --git a/src/Protocol/Client/Capabilities/CodeLensCapability.cs b/src/Protocol/Client/Capabilities/CodeLensCapability.cs
index f7d22e0c9..e5947ddc6 100644
--- a/src/Protocol/Client/Capabilities/CodeLensCapability.cs
+++ b/src/Protocol/Client/Capabilities/CodeLensCapability.cs
@@ -1,6 +1,7 @@
 using OmniSharp.Extensions.LanguageServer.Protocol.Document;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities
 {
-    public class CodeLensCapability : DynamicCapability, ConnectedCapability<ICodeLensHandler> { }
+    public class CodeLensCapability : DynamicCapability, ConnectedCapability<ICodeLensHandler<CanBeResolvedData>> { }
 }
diff --git a/src/Protocol/Client/Capabilities/CompletionCapability.cs b/src/Protocol/Client/Capabilities/CompletionCapability.cs
index 896c5359c..418ec38fc 100644
--- a/src/Protocol/Client/Capabilities/CompletionCapability.cs
+++ b/src/Protocol/Client/Capabilities/CompletionCapability.cs
@@ -1,9 +1,10 @@
 using OmniSharp.Extensions.LanguageServer.Protocol.Document;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities
 {
-    public class CompletionCapability : DynamicCapability, ConnectedCapability<ICompletionHandler>
+    public class CompletionCapability : DynamicCapability, ConnectedCapability<ICompletionHandler<CanBeResolvedData>>
     {
         /// <summary>
         /// The client supports the following `CompletionItem` specific
diff --git a/src/Protocol/Client/Capabilities/DocumentLinkCapability.cs b/src/Protocol/Client/Capabilities/DocumentLinkCapability.cs
index 2c13d8572..993523be4 100644
--- a/src/Protocol/Client/Capabilities/DocumentLinkCapability.cs
+++ b/src/Protocol/Client/Capabilities/DocumentLinkCapability.cs
@@ -1,9 +1,10 @@
 using OmniSharp.Extensions.LanguageServer.Protocol.Document;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities
 {
-    public class DocumentLinkCapability : DynamicCapability, ConnectedCapability<IDocumentLinkHandler>
+    public class DocumentLinkCapability : DynamicCapability, ConnectedCapability<IDocumentLinkHandler<CanBeResolvedData>>
     {
         /// <summary>
         /// Whether the client support the `tooltip` property on `DocumentLink`.
diff --git a/src/Protocol/DelegatingHandlers.cs b/src/Protocol/DelegatingHandlers.cs
index 9fc124343..c8fb222aa 100644
--- a/src/Protocol/DelegatingHandlers.cs
+++ b/src/Protocol/DelegatingHandlers.cs
@@ -13,12 +13,12 @@
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol
 {
-
     public static class LanguageProtocolDelegatingHandlers
     {
         public sealed class Request<TParams, TResult, TCapability, TRegistrationOptions> :
             IJsonRpcRequestHandler<TParams, TResult>,
-            IRegistration<TRegistrationOptions>, ICapability<TCapability>
+            IRegistration<TRegistrationOptions>, ICapability<TCapability>,
+            ICanBeIdentifiedHandler
             where TParams : IRequest<TResult>
             where TRegistrationOptions : class, new()
             where TCapability : ICapability
@@ -26,17 +26,27 @@ public sealed class Request<TParams, TResult, TCapability, TRegistrationOptions>
             private readonly Func<TParams, TCapability, CancellationToken, Task<TResult>> _handler;
             private readonly TRegistrationOptions _registrationOptions;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public Request(Func<TParams, TCapability, Task<TResult>> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), (a, c, ct) => handler(a, c), registrationOptions)
+            {
+            }
+
+            public Request(Func<TParams, TCapability, CancellationToken, Task<TResult>> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), handler, registrationOptions)
+            {
+            }
 
-            public Request(
-                Func<TParams, TCapability, Task<TResult>> handler,
-                TRegistrationOptions registrationOptions) : this((a, c, ct) => handler(a, c), registrationOptions)
+            public Request(Guid id, Func<TParams, TCapability, Task<TResult>> handler, TRegistrationOptions registrationOptions) :
+                this(id, (a, c, ct) => handler(a, c), registrationOptions)
             {
             }
 
-            public Request(
-                Func<TParams, TCapability, CancellationToken, Task<TResult>> handler,
-                TRegistrationOptions registrationOptions)
+            public Request(Guid id, Func<TParams, TCapability, CancellationToken, Task<TResult>> handler, TRegistrationOptions registrationOptions)
             {
+                _id = id;
                 _handler = handler;
                 _registrationOptions = registrationOptions;
             }
@@ -49,89 +59,72 @@ Task<TResult> IRequestHandler<TParams, TResult>.
             void ICapability<TCapability>.SetCapability(TCapability capability) => _capability = capability;
         }
 
-        public sealed class CanBeResolved<TItem, TCapability, TRegistrationOptions> :
+        public sealed class CanBeResolved<TItem, TCapability, TRegistrationOptions, TData> :
             IRegistration<TRegistrationOptions>,
             ICapability<TCapability>,
-            ICanBeResolvedHandler<TItem>
-            where TItem : ICanBeResolved, IRequest<TItem>
+            ICanBeResolvedHandler<TItem, TData>
+            where TItem : ICanBeResolved<TData>, IRequest<TItem>
             where TRegistrationOptions : class, new()
             where TCapability : ICapability
+            where TData : CanBeResolvedData
         {
-            private readonly Func<TItem, bool> _canResolve;
             private readonly Func<TItem, TCapability, CancellationToken, Task<TItem>> _resolveHandler;
             private readonly TRegistrationOptions _registrationOptions;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
 
-            public CanBeResolved(
-                Func<TItem, TCapability, Task<TItem>> resolveHandler,
-                Func<TItem, bool> canResolve,
-                TRegistrationOptions registrationOptions) : this(
-                (a, c, ct) => resolveHandler(a, c) ,
-                canResolve,
-                registrationOptions)
+            public CanBeResolved(Guid id, Func<TItem, TCapability, Task<TItem>> resolveHandler, TRegistrationOptions registrationOptions) :
+                this(id, (a, c, ct) => resolveHandler(a, c), registrationOptions)
             {
             }
 
-            public CanBeResolved(
-                Func<TItem, TCapability, CancellationToken, Task<TItem>> resolveHandler,
-                Func<TItem, bool> canResolve,
-                TRegistrationOptions registrationOptions)
+            public CanBeResolved(Guid id, Func<TItem, TCapability, CancellationToken, Task<TItem>> resolveHandler, TRegistrationOptions registrationOptions)
             {
-                _canResolve = canResolve;
                 _resolveHandler = resolveHandler;
                 _registrationOptions = registrationOptions;
+                _id = id;
             }
 
-            Task<TItem> IRequestHandler<TItem, TItem>.
-                Handle(TItem request, CancellationToken cancellationToken) =>
-                _resolveHandler(request, _capability, cancellationToken);
+            Task<TItem> IRequestHandler<TItem, TItem>.Handle(TItem request, CancellationToken cancellationToken) => _resolveHandler(request, _capability, cancellationToken);
 
             TRegistrationOptions IRegistration<TRegistrationOptions>.GetRegistrationOptions() => _registrationOptions;
             void ICapability<TCapability>.SetCapability(TCapability capability) => _capability = capability;
-            bool ICanBeResolvedHandler<TItem>.CanResolve(TItem value) => _canResolve(value);
         }
 
-        public sealed class CanBeResolved<TItem, TRegistrationOptions> :
+        public sealed class CanBeResolved<TItem, TRegistrationOptions, TData> :
             IRegistration<TRegistrationOptions>,
-            ICanBeResolvedHandler<TItem>
-            where TItem : ICanBeResolved, IRequest<TItem>
+            ICanBeResolvedHandler<TItem, TData>
+            where TItem : ICanBeResolved<TData>, IRequest<TItem>
             where TRegistrationOptions : class, new()
+            where TData : CanBeResolvedData
         {
-            private readonly Func<TItem, bool> _canResolve;
             private readonly Func<TItem, CancellationToken, Task<TItem>> _resolveHandler;
             private readonly TRegistrationOptions _registrationOptions;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
 
-            public CanBeResolved(
-                Func<TItem, Task<TItem>> resolveHandler,
-                Func<TItem, bool> canResolve,
-                TRegistrationOptions registrationOptions) : this(
-                (a, c) => resolveHandler(a) ,
-                canResolve,
-                registrationOptions)
+            public CanBeResolved(Guid id, Func<TItem, Task<TItem>> resolveHandler, TRegistrationOptions registrationOptions) :
+                this(id, (a, c) => resolveHandler(a), registrationOptions)
             {
             }
 
-            public CanBeResolved(
-                Func<TItem, CancellationToken, Task<TItem>> resolveHandler,
-                Func<TItem, bool> canResolve,
-                TRegistrationOptions registrationOptions)
+            public CanBeResolved(Guid id, Func<TItem, CancellationToken, Task<TItem>> resolveHandler, TRegistrationOptions registrationOptions)
             {
-                _canResolve = canResolve;
+                _id = id;
                 _resolveHandler = resolveHandler;
                 _registrationOptions = registrationOptions;
             }
 
-            Task<TItem> IRequestHandler<TItem, TItem>.
-                Handle(TItem request, CancellationToken cancellationToken) =>
-                _resolveHandler(request, cancellationToken);
+            Task<TItem> IRequestHandler<TItem, TItem>.Handle(TItem request, CancellationToken cancellationToken) => _resolveHandler(request, cancellationToken);
 
             TRegistrationOptions IRegistration<TRegistrationOptions>.GetRegistrationOptions() => _registrationOptions;
-            bool ICanBeResolvedHandler<TItem>.CanResolve(TItem value) => _canResolve(value);
         }
 
         public sealed class Request<TParams, TCapability, TRegistrationOptions> :
             IJsonRpcRequestHandler<TParams>,
-            IRegistration<TRegistrationOptions>, ICapability<TCapability>
+            IRegistration<TRegistrationOptions>, ICapability<TCapability>,
+            ICanBeIdentifiedHandler
             where TParams : IRequest
             where TRegistrationOptions : class, new()
             where TCapability : ICapability
@@ -139,27 +132,36 @@ public sealed class Request<TParams, TCapability, TRegistrationOptions> :
             private readonly Func<TParams, TCapability, CancellationToken, Task> _handler;
             private readonly TRegistrationOptions _registrationOptions;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
 
-            public Request(
-                Func<TParams, TCapability, Task> handler,
-                TRegistrationOptions registrationOptions) : this((a, c, ct) => handler(a, c), registrationOptions)
+            public Request(Func<TParams, TCapability, Task> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), (a, c, ct) => handler(a, c), registrationOptions)
             {
             }
 
-            public Request(
-                Func<TParams, TCapability, CancellationToken, Task> handler,
-                TRegistrationOptions registrationOptions)
+            public Request(Func<TParams, TCapability, CancellationToken, Task> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), handler, registrationOptions)
             {
+            }
+
+
+            public Request(Guid id, Func<TParams, TCapability, Task> handler, TRegistrationOptions registrationOptions) :
+                this(id, (a, c, ct) => handler(a, c), registrationOptions)
+            {
+            }
+
+            public Request(Guid id, Func<TParams, TCapability, CancellationToken, Task> handler, TRegistrationOptions registrationOptions)
+            {
+                _id = id;
                 _handler = handler;
                 _registrationOptions = registrationOptions;
             }
 
-            async Task<Unit> IRequestHandler<TParams, Unit>.
-                Handle(TParams request, CancellationToken cancellationToken)
+            async Task<Unit> IRequestHandler<TParams, Unit>.Handle(TParams request, CancellationToken cancellationToken)
             {
                 await _handler(request, _capability, cancellationToken);
                 return Unit.Value;
-                ;
             }
 
             TRegistrationOptions IRegistration<TRegistrationOptions>.GetRegistrationOptions() => _registrationOptions;
@@ -168,53 +170,73 @@ async Task<Unit> IRequestHandler<TParams, Unit>.
 
         public sealed class RequestRegistration<TParams, TResult, TRegistrationOptions> :
             IJsonRpcRequestHandler<TParams, TResult>,
-            IRegistration<TRegistrationOptions>
+            IRegistration<TRegistrationOptions>,
+            ICanBeIdentifiedHandler
             where TParams : IRequest<TResult>
             where TRegistrationOptions : class, new()
         {
             private readonly Func<TParams, CancellationToken, Task<TResult>> _handler;
             private readonly TRegistrationOptions _registrationOptions;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public RequestRegistration(Func<TParams, Task<TResult>> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), (a, ct) => handler(a), registrationOptions)
+            {
+            }
+
+            public RequestRegistration(Func<TParams, CancellationToken, Task<TResult>> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), handler, registrationOptions)
+            {
+            }
 
-            public RequestRegistration(
-                Func<TParams, Task<TResult>> handler,
-                TRegistrationOptions registrationOptions) : this((a, ct) => handler(a), registrationOptions)
+            public RequestRegistration(Guid id, Func<TParams, Task<TResult>> handler, TRegistrationOptions registrationOptions) :
+                this(id, (a, ct) => handler(a), registrationOptions)
             {
             }
 
-            public RequestRegistration(
-                Func<TParams, CancellationToken, Task<TResult>> handler,
-                TRegistrationOptions registrationOptions)
+            public RequestRegistration(Guid id, Func<TParams, CancellationToken, Task<TResult>> handler, TRegistrationOptions registrationOptions)
             {
+                _id = id;
                 _handler = handler;
                 _registrationOptions = registrationOptions;
             }
 
-            Task<TResult> IRequestHandler<TParams, TResult>.
-                Handle(TParams request, CancellationToken cancellationToken) =>
-                _handler(request, cancellationToken);
+            Task<TResult> IRequestHandler<TParams, TResult>.Handle(TParams request, CancellationToken cancellationToken) => _handler(request, cancellationToken);
 
             TRegistrationOptions IRegistration<TRegistrationOptions>.GetRegistrationOptions() => _registrationOptions;
         }
 
         public sealed class RequestRegistration<TParams, TRegistrationOptions> :
             IJsonRpcRequestHandler<TParams>,
-            IRegistration<TRegistrationOptions>
+            IRegistration<TRegistrationOptions>,
+            ICanBeIdentifiedHandler
             where TParams : IRequest
             where TRegistrationOptions : class, new()
         {
             private readonly Func<TParams, CancellationToken, Task> _handler;
             private readonly TRegistrationOptions _registrationOptions;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
 
-            public RequestRegistration(
-                Func<TParams, Task> handler,
-                TRegistrationOptions registrationOptions) : this((a, ct) => handler(a), registrationOptions)
+            public RequestRegistration(Func<TParams, Task> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), (a, ct) => handler(a), registrationOptions)
             {
             }
 
-            public RequestRegistration(
-                Func<TParams, CancellationToken, Task> handler,
-                TRegistrationOptions registrationOptions)
+            public RequestRegistration(Func<TParams, CancellationToken, Task> handler, TRegistrationOptions registrationOptions):
+                this(Guid.NewGuid(), handler, registrationOptions)
             {
+            }
+
+            public RequestRegistration(Guid id, Func<TParams, Task> handler, TRegistrationOptions registrationOptions) :
+                this(id, (a, ct) => handler(a), registrationOptions)
+            {
+            }
+
+            public RequestRegistration(Guid id, Func<TParams, CancellationToken, Task> handler, TRegistrationOptions registrationOptions)
+            {
+                _id = id;
                 _handler = handler;
                 _registrationOptions = registrationOptions;
             }
@@ -231,21 +253,34 @@ async Task<Unit> IRequestHandler<TParams, Unit>.
 
         public sealed class RequestCapability<TParams, TResult, TCapability> :
             IJsonRpcRequestHandler<TParams, TResult>,
-            ICapability<TCapability>
+            ICapability<TCapability>,
+            ICanBeIdentifiedHandler
             where TParams : IRequest<TResult>
             where TCapability : ICapability
         {
             private readonly Func<TParams, TCapability, CancellationToken, Task<TResult>> _handler;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public RequestCapability(Func<TParams, TCapability, Task<TResult>> handler) :
+                this(Guid.NewGuid(), (a, c, ct) => handler(a, c))
+            {
+            }
+
+            public RequestCapability(Func<TParams, TCapability, CancellationToken, Task<TResult>> handler):
+                this(Guid.NewGuid(), handler)
+            {
+            }
 
-            public RequestCapability(
-                Func<TParams, TCapability, Task<TResult>> handler) : this((a, c, ct) => handler(a, c))
+            public RequestCapability(Guid id, Func<TParams, TCapability, Task<TResult>> handler) :
+                this(id, (a, c, ct) => handler(a, c))
             {
             }
 
-            public RequestCapability(
-                Func<TParams, TCapability, CancellationToken, Task<TResult>> handler)
+            public RequestCapability(Guid id, Func<TParams, TCapability, CancellationToken, Task<TResult>> handler)
             {
+                _id = id;
                 _handler = handler;
             }
 
@@ -258,21 +293,34 @@ Task<TResult> IRequestHandler<TParams, TResult>.
 
         public sealed class RequestCapability<TParams, TCapability> :
             IJsonRpcRequestHandler<TParams>,
-            ICapability<TCapability>
+            ICapability<TCapability>,
+            ICanBeIdentifiedHandler
             where TParams : IRequest
             where TCapability : ICapability
         {
             private readonly Func<TParams, TCapability, CancellationToken, Task> _handler;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public RequestCapability(Func<TParams, TCapability, Task> handler) :
+                this(Guid.NewGuid(), handler)
+            {
+            }
 
-            public RequestCapability(
-                Func<TParams, TCapability, Task> handler) : this((a, c, ct) => handler(a, c))
+            public RequestCapability(Func<TParams, TCapability, CancellationToken, Task> handler):
+                this(Guid.NewGuid(), handler)
             {
             }
 
-            public RequestCapability(
-                Func<TParams, TCapability, CancellationToken, Task> handler)
+            public RequestCapability(Guid id, Func<TParams, TCapability, Task> handler) :
+                this(id, (a, c, ct) => handler(a, c))
             {
+            }
+
+            public RequestCapability(Guid id, Func<TParams, TCapability, CancellationToken, Task> handler)
+            {
+                _id = id;
                 _handler = handler;
             }
 
@@ -288,7 +336,8 @@ async Task<Unit> IRequestHandler<TParams, Unit>.
 
         public sealed class PartialResult<TItem, TResponse, TCapability, TRegistrationOptions> :
             IJsonRpcRequestHandler<TItem, TResponse>,
-            IRegistration<TRegistrationOptions>, ICapability<TCapability>
+            IRegistration<TRegistrationOptions>, ICapability<TCapability>,
+            ICanBeIdentifiedHandler
             where TItem : IPartialItemRequest<TResponse, TItem>
             where TResponse : class, new()
             where TRegistrationOptions : class, new()
@@ -299,22 +348,27 @@ public sealed class PartialResult<TItem, TResponse, TCapability, TRegistrationOp
             private readonly TRegistrationOptions _registrationOptions;
             private readonly IProgressManager _progressManager;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
 
-            public PartialResult(
-                Action<TItem, IObserver<TItem>, TCapability> handler,
-                TRegistrationOptions registrationOptions,
-                IProgressManager progressManager,
-                Func<TItem, TResponse> factory) : this((p, o, c, ct) => handler(p, o, c), registrationOptions,
-                progressManager, factory)
+            public PartialResult(Action<TItem, IObserver<TItem>, TCapability> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<TItem, TResponse> factory) :
+                this(Guid.NewGuid(), (p, o, c, ct) => handler(p, o, c), registrationOptions, progressManager, factory)
             {
             }
 
-            public PartialResult(
-                Action<TItem, IObserver<TItem>, TCapability, CancellationToken> handler,
-                TRegistrationOptions registrationOptions,
-                IProgressManager progressManager,
-                Func<TItem, TResponse> factory)
+            public PartialResult(Action<TItem, IObserver<TItem>, TCapability, CancellationToken> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<TItem, TResponse> factory):
+                this(Guid.NewGuid(), handler, registrationOptions, progressManager, factory)
             {
+            }
+
+            public PartialResult(Guid id, Action<TItem, IObserver<TItem>, TCapability> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<TItem, TResponse> factory) :
+                this(id, (p, o, c, ct) => handler(p, o, c), registrationOptions, progressManager, factory)
+            {
+            }
+
+            public PartialResult(Guid id, Action<TItem, IObserver<TItem>, TCapability, CancellationToken> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<TItem, TResponse> factory)
+            {
+                _id = id;
                 _handler = handler;
                 _registrationOptions = registrationOptions;
                 _progressManager = progressManager;
@@ -343,7 +397,8 @@ async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request,
 
         public sealed class PartialResult<TItem, TResponse, TRegistrationOptions> :
             IJsonRpcRequestHandler<TItem, TResponse>,
-            IRegistration<TRegistrationOptions>
+            IRegistration<TRegistrationOptions>,
+            ICanBeIdentifiedHandler
             where TItem : IPartialItemRequest<TResponse, TItem>
             where TResponse : class, new()
             where TRegistrationOptions : class, new()
@@ -352,30 +407,34 @@ public sealed class PartialResult<TItem, TResponse, TRegistrationOptions> :
             private readonly TRegistrationOptions _registrationOptions;
             private readonly IProgressManager _progressManager;
             private readonly Func<TItem, TResponse> _factory;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public PartialResult(Action<TItem, IObserver<TItem>> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<TItem, TResponse> factory) :
+                this(Guid.NewGuid(), (p, o, ct) => handler(p, o), registrationOptions, progressManager, factory)
+            {
+            }
 
-            public PartialResult(
-                Action<TItem, IObserver<TItem>> handler,
-                TRegistrationOptions registrationOptions,
-                IProgressManager progressManager,
-                Func<TItem, TResponse> factory) : this((p, o, ct) => handler(p, o), registrationOptions,
-                progressManager, factory)
+            public PartialResult(Action<TItem, IObserver<TItem>, CancellationToken> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<TItem, TResponse> factory):
+                this(Guid.NewGuid(), handler, registrationOptions, progressManager, factory)
             {
             }
 
-            public PartialResult(
-                Action<TItem, IObserver<TItem>, CancellationToken> handler,
-                TRegistrationOptions registrationOptions,
-                IProgressManager progressManager,
-                Func<TItem, TResponse> factory)
+            public PartialResult(Guid id, Action<TItem, IObserver<TItem>> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<TItem, TResponse> factory) :
+                this(id, (p, o, ct) => handler(p, o), registrationOptions, progressManager, factory)
             {
+            }
+
+            public PartialResult(Guid id, Action<TItem, IObserver<TItem>, CancellationToken> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<TItem, TResponse> factory)
+            {
+                _id = id;
                 _handler = handler;
                 _registrationOptions = registrationOptions;
                 _progressManager = progressManager;
                 _factory = factory;
             }
 
-            async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request,
-                CancellationToken cancellationToken)
+            async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request, CancellationToken cancellationToken)
             {
                 var observer = _progressManager.For(request, cancellationToken);
                 if (observer != null)
@@ -395,7 +454,8 @@ async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request,
 
         public sealed class PartialResultCapability<TItem, TResponse, TCapability> :
             IJsonRpcRequestHandler<TItem, TResponse>,
-            ICapability<TCapability>
+            ICapability<TCapability>,
+            ICanBeIdentifiedHandler
             where TItem : IPartialItemRequest<TResponse, TItem>
             where TResponse : class, new()
             where TCapability : ICapability
@@ -404,27 +464,33 @@ public sealed class PartialResultCapability<TItem, TResponse, TCapability> :
             private readonly IProgressManager _progressManager;
             private readonly Func<TItem, TResponse> _factory;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
 
-            public PartialResultCapability(
-                Action<TItem, TCapability, IObserver<TItem>> handler,
-                IProgressManager progressManager,
-                Func<TItem, TResponse> factory) : this((p, c, o, ct) => handler(p, c, o),
-                progressManager, factory)
+            public PartialResultCapability(Action<TItem, TCapability, IObserver<TItem>> handler, IProgressManager progressManager, Func<TItem, TResponse> factory) :
+                this((p, c, o, ct) => handler(p, c, o), progressManager, factory)
             {
             }
 
-            public PartialResultCapability(
-                Action<TItem, TCapability, IObserver<TItem>, CancellationToken> handler,
-                IProgressManager progressManager,
-                Func<TItem, TResponse> factory)
+            public PartialResultCapability(Action<TItem, TCapability, IObserver<TItem>, CancellationToken> handler, IProgressManager progressManager, Func<TItem, TResponse> factory):
+                this(Guid.NewGuid(), handler, progressManager, factory)
             {
+            }
+
+            public PartialResultCapability(Guid id, Action<TItem, TCapability, IObserver<TItem>> handler, IProgressManager progressManager, Func<TItem, TResponse> factory) :
+                this(id, (p, c, o, ct) => handler(p, c, o), progressManager, factory)
+            {
+            }
+
+            public PartialResultCapability(Guid id, Action<TItem, TCapability, IObserver<TItem>, CancellationToken> handler, IProgressManager progressManager, Func<TItem, TResponse> factory)
+            {
+                _id = id;
                 _handler = handler;
                 _progressManager = progressManager;
                 _factory = factory;
             }
 
-            async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request,
-                CancellationToken cancellationToken)
+            async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request, CancellationToken cancellationToken)
             {
                 var observer = _progressManager.For(request, cancellationToken);
                 if (observer != null)
@@ -443,34 +509,44 @@ async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request,
         }
 
         public sealed class PartialResult<TItem, TResponse> :
-            IJsonRpcRequestHandler<TItem, TResponse>
+            IJsonRpcRequestHandler<TItem, TResponse>,
+            ICanBeIdentifiedHandler
             where TItem : IPartialItemRequest<TResponse, TItem>
             where TResponse : class, new()
         {
             private readonly Action<TItem, IObserver<TItem>, CancellationToken> _handler;
             private readonly IProgressManager _progressManager;
             private readonly Func<TItem, TResponse> _factory;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
 
-            public PartialResult(
-                Action<TItem, IObserver<TItem>> handler,
-                IProgressManager progressManager,
-                Func<TItem, TResponse> factory) : this((p, o, ct) => handler(p, o),
-                progressManager, factory)
+            public PartialResult(Action<TItem, IObserver<TItem>> handler, IProgressManager progressManager, Func<TItem, TResponse> factory) :
+                this(Guid.NewGuid(), (p, o, ct) => handler(p, o), progressManager, factory)
             {
             }
 
-            public PartialResult(
-                Action<TItem, IObserver<TItem>, CancellationToken> handler,
-                IProgressManager progressManager,
-                Func<TItem, TResponse> factory)
+            public PartialResult(Action<TItem, IObserver<TItem>, CancellationToken> handler, IProgressManager progressManager, Func<TItem, TResponse> factory):
+                this(Guid.NewGuid(), handler, progressManager,factory)
             {
                 _handler = handler;
                 _progressManager = progressManager;
                 _factory = factory;
             }
 
-            async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request,
-                CancellationToken cancellationToken)
+            public PartialResult(Guid id, Action<TItem, IObserver<TItem>> handler, IProgressManager progressManager, Func<TItem, TResponse> factory) :
+                this(id, (p, o, ct) => handler(p, o), progressManager, factory)
+            {
+            }
+
+            public PartialResult(Guid id, Action<TItem, IObserver<TItem>, CancellationToken> handler, IProgressManager progressManager, Func<TItem, TResponse> factory)
+            {
+                _id = id;
+                _handler = handler;
+                _progressManager = progressManager;
+                _factory = factory;
+            }
+
+            async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request, CancellationToken cancellationToken)
             {
                 var observer = _progressManager.For(request, cancellationToken);
                 if (observer != null)
@@ -488,7 +564,8 @@ async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request,
 
         public sealed class PartialResults<TParams, TResponse, TItem, TCapability, TRegistrationOptions> :
             IJsonRpcRequestHandler<TParams, TResponse>,
-            IRegistration<TRegistrationOptions>, ICapability<TCapability>
+            IRegistration<TRegistrationOptions>, ICapability<TCapability>,
+            ICanBeIdentifiedHandler
             where TParams : IPartialItemsRequest<TResponse, TItem>
             where TResponse : IEnumerable<TItem>, new()
             where TRegistrationOptions : class, new()
@@ -499,30 +576,34 @@ public sealed class PartialResults<TParams, TResponse, TItem, TCapability, TRegi
             private readonly IProgressManager _progressManager;
             private readonly Func<IEnumerable<TItem>, TResponse> _factory;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public PartialResults(Action<TParams, IObserver<IEnumerable<TItem>>, TCapability> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory) :
+                this(Guid.NewGuid(), (p, o, c, ct) => handler(p, o, c), registrationOptions, progressManager, factory)
+            {
+            }
 
-            public PartialResults(
-                Action<TParams, IObserver<IEnumerable<TItem>>, TCapability> handler,
-                TRegistrationOptions registrationOptions,
-                IProgressManager progressManager,
-                Func<IEnumerable<TItem>, TResponse> factory) : this((p, o, c, ct) => handler(p, o, c), registrationOptions,
-                progressManager, factory)
+            public PartialResults(Action<TParams, IObserver<IEnumerable<TItem>>, TCapability, CancellationToken> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory):
+                this(Guid.NewGuid(), handler, registrationOptions, progressManager, factory)
             {
             }
 
-            public PartialResults(
-                Action<TParams, IObserver<IEnumerable<TItem>>, TCapability, CancellationToken> handler,
-                TRegistrationOptions registrationOptions,
-                IProgressManager progressManager,
-                Func<IEnumerable<TItem>, TResponse> factory)
+            public PartialResults(Guid id, Action<TParams, IObserver<IEnumerable<TItem>>, TCapability> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory) :
+                this(id, (p, o, c, ct) => handler(p, o, c), registrationOptions, progressManager, factory)
             {
+            }
+
+            public PartialResults(Guid id, Action<TParams, IObserver<IEnumerable<TItem>>, TCapability, CancellationToken> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory)
+            {
+                _id = id;
                 _handler = handler;
                 _registrationOptions = registrationOptions;
                 _progressManager = progressManager;
                 _factory = factory;
             }
 
-            async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request,
-                CancellationToken cancellationToken)
+            async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request, CancellationToken cancellationToken)
             {
                 var observer = _progressManager.For(request, cancellationToken);
                 if (observer != null)
@@ -549,7 +630,8 @@ async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request
 
         public sealed class PartialResults<TParams, TResponse, TItem, TRegistrationOptions> :
             IJsonRpcRequestHandler<TParams, TResponse>,
-            IRegistration<TRegistrationOptions>
+            IRegistration<TRegistrationOptions>,
+            ICanBeIdentifiedHandler
             where TParams : IPartialItemsRequest<TResponse, TItem>
             where TResponse : IEnumerable<TItem>, new()
             where TRegistrationOptions : class, new()
@@ -558,30 +640,34 @@ public sealed class PartialResults<TParams, TResponse, TItem, TRegistrationOptio
             private readonly TRegistrationOptions _registrationOptions;
             private readonly IProgressManager _progressManager;
             private readonly Func<IEnumerable<TItem>, TResponse> _factory;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public PartialResults(Action<TParams, IObserver<IEnumerable<TItem>>> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory) :
+                this(Guid.NewGuid(), (p, o, ct) => handler(p, o), registrationOptions, progressManager, factory)
+            {
+            }
+
+            public PartialResults(Action<TParams, IObserver<IEnumerable<TItem>>, CancellationToken> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory):
+                this(Guid.NewGuid(), handler, registrationOptions, progressManager, factory)
+            {
+            }
 
-            public PartialResults(
-                Action<TParams, IObserver<IEnumerable<TItem>>> handler,
-                TRegistrationOptions registrationOptions,
-                IProgressManager progressManager,
-                Func<IEnumerable<TItem>, TResponse> factory) : this((p, o, ct) => handler(p, o), registrationOptions,
-                progressManager, factory)
+            public PartialResults(Guid id, Action<TParams, IObserver<IEnumerable<TItem>>> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory) :
+                this(id, (p, o, ct) => handler(p, o), registrationOptions, progressManager, factory)
             {
             }
 
-            public PartialResults(
-                Action<TParams, IObserver<IEnumerable<TItem>>, CancellationToken> handler,
-                TRegistrationOptions registrationOptions,
-                IProgressManager progressManager,
-                Func<IEnumerable<TItem>, TResponse> factory)
+            public PartialResults(Guid id, Action<TParams, IObserver<IEnumerable<TItem>>, CancellationToken> handler, TRegistrationOptions registrationOptions, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory)
             {
+                _id = id;
                 _handler = handler;
                 _registrationOptions = registrationOptions;
                 _progressManager = progressManager;
                 _factory = factory;
             }
 
-            async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request,
-                CancellationToken cancellationToken)
+            async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request, CancellationToken cancellationToken)
             {
                 var observer = _progressManager.For(request, cancellationToken);
                 if (observer != null)
@@ -606,7 +692,8 @@ async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request
         }
 
         public sealed class PartialResultsCapability<TParams, TResponse, TItem, TCapability> :
-            IJsonRpcRequestHandler<TParams, TResponse>, ICapability<TCapability>
+            IJsonRpcRequestHandler<TParams, TResponse>, ICapability<TCapability>,
+            ICanBeIdentifiedHandler
             where TParams : IPartialItemsRequest<TResponse, TItem>
             where TResponse : IEnumerable<TItem>, new()
             where TCapability : ICapability
@@ -615,27 +702,33 @@ public sealed class PartialResultsCapability<TParams, TResponse, TItem, TCapabil
             private readonly IProgressManager _progressManager;
             private readonly Func<IEnumerable<TItem>, TResponse> _factory;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public PartialResultsCapability(Action<TParams, TCapability, IObserver<IEnumerable<TItem>>> handler, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory) :
+                this(Guid.NewGuid(), (p, c, o, ct) => handler(p, c, o), progressManager, factory)
+            {
+            }
 
-            public PartialResultsCapability(
-                Action<TParams, TCapability, IObserver<IEnumerable<TItem>>> handler,
-                IProgressManager progressManager,
-                Func<IEnumerable<TItem>, TResponse> factory) : this((p, c, o, ct) => handler(p, c, o),
-                progressManager, factory)
+            public PartialResultsCapability(Action<TParams, TCapability, IObserver<IEnumerable<TItem>>, CancellationToken> handler, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory):
+                this(Guid.NewGuid(), handler, progressManager, factory)
             {
             }
 
-            public PartialResultsCapability(
-                Action<TParams, TCapability, IObserver<IEnumerable<TItem>>, CancellationToken> handler,
-                IProgressManager progressManager,
-                Func<IEnumerable<TItem>, TResponse> factory)
+            public PartialResultsCapability(Guid id, Action<TParams, TCapability, IObserver<IEnumerable<TItem>>> handler, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory) :
+                this(id, (p, c, o, ct) => handler(p, c, o), progressManager, factory)
             {
+            }
+
+            public PartialResultsCapability(Guid id, Action<TParams, TCapability, IObserver<IEnumerable<TItem>>, CancellationToken> handler, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory)
+            {
+                _id = id;
                 _handler = handler;
                 _progressManager = progressManager;
                 _factory = factory;
             }
 
-            async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request,
-                CancellationToken cancellationToken)
+            async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request, CancellationToken cancellationToken)
             {
                 var observer = _progressManager.For(request, cancellationToken);
                 if (observer != null)
@@ -660,34 +753,44 @@ async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request
         }
 
         public sealed class PartialResults<TParams, TResponse, TItem> :
-            IJsonRpcRequestHandler<TParams, TResponse>
+            IJsonRpcRequestHandler<TParams, TResponse>,
+            ICanBeIdentifiedHandler
             where TParams : IPartialItemsRequest<TResponse, TItem>
             where TResponse : IEnumerable<TItem>, new()
         {
             private readonly Action<TParams, IObserver<IEnumerable<TItem>>, CancellationToken> _handler;
             private readonly IProgressManager _progressManager;
             private readonly Func<IEnumerable<TItem>, TResponse> _factory;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
 
-            public PartialResults(
-                Action<TParams, IObserver<IEnumerable<TItem>>> handler,
-                IProgressManager progressManager,
-                Func<IEnumerable<TItem>, TResponse> factory) : this((p, o, ct) => handler(p, o),
-                progressManager, factory)
+            public PartialResults(Action<TParams, IObserver<IEnumerable<TItem>>> handler, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory) :
+                this(Guid.NewGuid(), (p, o, ct) => handler(p, o), progressManager, factory)
             {
             }
 
-            public PartialResults(
-                Action<TParams, IObserver<IEnumerable<TItem>>, CancellationToken> handler,
-                IProgressManager progressManager,
-                Func<IEnumerable<TItem>, TResponse> factory)
+            public PartialResults(Action<TParams, IObserver<IEnumerable<TItem>>, CancellationToken> handler, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory):
+                this(Guid.NewGuid(), handler, progressManager, factory)
             {
                 _handler = handler;
                 _progressManager = progressManager;
                 _factory = factory;
             }
 
-            async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request,
-                CancellationToken cancellationToken)
+            public PartialResults(Guid id, Action<TParams, IObserver<IEnumerable<TItem>>> handler, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory) :
+                this(id, (p, o, ct) => handler(p, o), progressManager, factory)
+            {
+            }
+
+            public PartialResults(Guid id, Action<TParams, IObserver<IEnumerable<TItem>>, CancellationToken> handler, IProgressManager progressManager, Func<IEnumerable<TItem>, TResponse> factory)
+            {
+                _id = id;
+                _handler = handler;
+                _progressManager = progressManager;
+                _factory = factory;
+            }
+
+            async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request, CancellationToken cancellationToken)
             {
                 var observer = _progressManager.For(request, cancellationToken);
                 if (observer != null)
@@ -711,7 +814,8 @@ async Task<TResponse> IRequestHandler<TParams, TResponse>.Handle(TParams request
 
         public sealed class Notification<TParams, TCapability, TRegistrationOptions> :
             IJsonRpcNotificationHandler<TParams>,
-            IRegistration<TRegistrationOptions>, ICapability<TCapability>
+            IRegistration<TRegistrationOptions>, ICapability<TCapability>,
+            ICanBeIdentifiedHandler
             where TParams : IRequest
             where TRegistrationOptions : class, new()
             where TCapability : ICapability
@@ -719,42 +823,54 @@ public sealed class Notification<TParams, TCapability, TRegistrationOptions> :
             private readonly Func<TParams, TCapability, CancellationToken, Task> _handler;
             private readonly TRegistrationOptions _registrationOptions;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public Notification(Action<TParams, TCapability> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), (request, capability, ct) => { handler(request, capability); return Task.CompletedTask; }, registrationOptions)
+            {
+            }
 
-            public Notification(
-                Action<TParams, TCapability> handler,
-                TRegistrationOptions registrationOptions) : this((request, capability, ct) => {
-                handler(request, capability);
-                return Task.CompletedTask;
-            }, registrationOptions)
+            public Notification(Action<TParams, TCapability, CancellationToken> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), (request, c, ct) => { handler(request, c, ct); return Task.CompletedTask; }, registrationOptions)
             {
             }
 
-            public Notification(
-                Action<TParams, TCapability, CancellationToken> handler,
-                TRegistrationOptions registrationOptions) : this((request, c, ct) => {
-                handler(request, c, ct);
-                return Task.CompletedTask;
-            }, registrationOptions)
+            public Notification(Func<TParams, TCapability, Task> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), (request, capability, ct) => handler(request, capability), registrationOptions)
             {
             }
 
-            public Notification(
-                Func<TParams, TCapability, Task> handler,
-                TRegistrationOptions registrationOptions) : this((request, capability, ct) => handler(request, capability), registrationOptions)
+            public Notification(Func<TParams, TCapability, CancellationToken, Task> handler, TRegistrationOptions registrationOptions):
+                this(Guid.NewGuid(), handler, registrationOptions)
             {
             }
 
-            public Notification(
-                Func<TParams, TCapability, CancellationToken, Task> handler,
-                TRegistrationOptions registrationOptions)
+            public Notification(Guid id, Action<TParams, TCapability> handler, TRegistrationOptions registrationOptions) :
+                this(id, (request, capability, ct) => { handler(request, capability); return Task.CompletedTask; }, registrationOptions)
             {
+            }
+
+            public Notification(                Guid id, Action<TParams, TCapability, CancellationToken> handler, TRegistrationOptions registrationOptions) :
+                this(id, (request, c, ct) => { handler(request, c, ct); return Task.CompletedTask; }, registrationOptions)
+            {
+            }
+
+            public Notification(Guid id, Func<TParams, TCapability, Task> handler, TRegistrationOptions registrationOptions) :
+                this(id, (request, capability, ct) => handler(request, capability), registrationOptions)
+            {
+            }
+
+            public Notification(Guid id, Func<TParams, TCapability, CancellationToken, Task> handler, TRegistrationOptions registrationOptions)
+            {
+                _id = id;
                 _handler = handler;
                 _registrationOptions = registrationOptions;
             }
 
             async Task<Unit> IRequestHandler<TParams, Unit>.Handle(TParams request, CancellationToken cancellationToken)
             {
-                await                _handler(request, _capability, cancellationToken);
+                await _handler(request, _capability, cancellationToken);
                 return Unit.Value;
             }
 
@@ -764,41 +880,54 @@ async Task<Unit> IRequestHandler<TParams, Unit>.Handle(TParams request, Cancella
 
         public sealed class Notification<TParams, TRegistrationOptions> :
             IJsonRpcNotificationHandler<TParams>,
-            IRegistration<TRegistrationOptions>
+            IRegistration<TRegistrationOptions>,
+            ICanBeIdentifiedHandler
             where TParams : IRequest
             where TRegistrationOptions : class, new()
         {
             private readonly Func<TParams, CancellationToken, Task> _handler;
             private readonly TRegistrationOptions _registrationOptions;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public Notification(Action<TParams> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), (request, ct) => { handler(request); return Task.CompletedTask; }, registrationOptions)
+            {
+            }
 
-            public Notification(
-                Action<TParams> handler,
-                TRegistrationOptions registrationOptions) : this((request, ct) => {
-                handler(request);
-                return Task.CompletedTask;
-            }, registrationOptions)
+            public Notification(Action<TParams, CancellationToken> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), (request, ct) => { handler(request, ct); return Task.CompletedTask; }, registrationOptions)
             {
             }
 
-            public Notification(
-                Action<TParams, CancellationToken> handler,
-                TRegistrationOptions registrationOptions) : this((request, ct) => {
-                handler(request, ct);
-                return Task.CompletedTask;
-            }, registrationOptions)
+            public Notification(Func<TParams, Task> handler, TRegistrationOptions registrationOptions) :
+                this(Guid.NewGuid(), (request, ct) => handler(request), registrationOptions)
             {
             }
 
-            public Notification(
-                Func<TParams, Task> handler,
-                TRegistrationOptions registrationOptions) : this((request, ct) => handler(request), registrationOptions)
+            public Notification(Func<TParams, CancellationToken, Task> handler, TRegistrationOptions registrationOptions):
+                this(Guid.NewGuid(), handler, registrationOptions)
             {
             }
 
-            public Notification(
-                Func<TParams, CancellationToken, Task> handler,
-                TRegistrationOptions registrationOptions)
+            public Notification(Guid id, Action<TParams> handler, TRegistrationOptions registrationOptions) :
+                this(id,(request, ct) => { handler(request); return Task.CompletedTask; }, registrationOptions)
             {
+            }
+
+            public Notification(Guid id, Action<TParams, CancellationToken> handler, TRegistrationOptions registrationOptions) :
+                this(id, (request, ct) => { handler(request, ct); return Task.CompletedTask; }, registrationOptions)
+            {
+            }
+
+            public Notification(Guid id, Func<TParams, Task> handler, TRegistrationOptions registrationOptions) :
+                this(id, (request, ct) => handler(request), registrationOptions)
+            {
+            }
+
+            public Notification(Guid id, Func<TParams, CancellationToken, Task> handler, TRegistrationOptions registrationOptions)
+            {
+                _id = id;
                 _handler = handler;
                 _registrationOptions = registrationOptions;
             }
@@ -813,29 +942,44 @@ async Task<Unit> IRequestHandler<TParams, Unit>.Handle(TParams request, Cancella
         }
 
         public sealed class NotificationCapability<TParams, TCapability> :
-            IJsonRpcNotificationHandler<TParams>, ICapability<TCapability>
+            IJsonRpcNotificationHandler<TParams>, ICapability<TCapability>,
+            ICanBeIdentifiedHandler
             where TParams : IRequest
             where TCapability : ICapability
         {
             private readonly Func<TParams, TCapability, CancellationToken, Task> _handler;
             private TCapability _capability;
+            private readonly Guid _id;
+            Guid ICanBeIdentifiedHandler.Id => _id;
+
+            public NotificationCapability(Action<TParams, TCapability> handler) :
+                this(Guid.NewGuid(), (request, capability, ct) => { handler(request, capability); return Task.CompletedTask; })
+            {
+            }
+
+            public NotificationCapability(Func<TParams, TCapability, Task> handler) :
+                this(Guid.NewGuid(), (request, capability, ct) => handler(request, capability))
+            {
+            }
+
+            public NotificationCapability(Func<TParams, TCapability, CancellationToken, Task> handler) :
+                this(Guid.NewGuid(), handler)
+            {
+            }
 
-            public NotificationCapability(
-                Action<TParams, TCapability> handler) : this((request, capability, ct) => {
-                handler(request, capability);
-                return Task.CompletedTask;
-            })
+            public NotificationCapability(Guid id, Action<TParams, TCapability> handler) :
+                this(id, (request, capability, ct) => { handler(request, capability); return Task.CompletedTask; })
             {
             }
 
-            public NotificationCapability(
-                Func<TParams, TCapability, Task> handler) : this((request, capability, ct) => handler(request, capability))
+            public NotificationCapability(Guid id, Func<TParams, TCapability, Task> handler) :
+                this(id, (request, capability, ct) => handler(request, capability))
             {
             }
 
-            public NotificationCapability(
-                Func<TParams, TCapability, CancellationToken, Task> handler)
+            public NotificationCapability(Guid id, Func<TParams, TCapability, CancellationToken, Task> handler)
             {
+                _id = id;
                 _handler = handler;
             }
 
diff --git a/src/Protocol/Document/ICodeLensHandler.cs b/src/Protocol/Document/ICodeLensHandler.cs
index 653fb732c..55aedeb78 100644
--- a/src/Protocol/Document/ICodeLensHandler.cs
+++ b/src/Protocol/Document/ICodeLensHandler.cs
@@ -14,18 +14,21 @@
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Document
 {
     [Parallel, Method(TextDocumentNames.CodeLens, Direction.ClientToServer)]
-    public interface ICodeLensHandler : IJsonRpcRequestHandler<CodeLensParams, CodeLensContainer>, IRegistration<CodeLensRegistrationOptions>, ICapability<CodeLensCapability>
+    public interface ICodeLensHandler<TData> : IJsonRpcRequestHandler<CodeLensParams<TData>, CodeLensContainer<TData>>, IRegistration<CodeLensRegistrationOptions>,
+        ICapability<CodeLensCapability> where TData : CanBeResolvedData
     {
     }
 
     [Parallel, Method(TextDocumentNames.CodeLensResolve, Direction.ClientToServer)]
-    public interface ICodeLensResolveHandler : ICanBeResolvedHandler<CodeLens>
+    public interface ICodeLensResolveHandler<TData> : ICanBeResolvedHandler<CodeLens<TData>, TData> where TData : CanBeResolvedData
     {
     }
 
-    public abstract class CodeLensHandler : ICodeLensHandler, ICodeLensResolveHandler
+    public abstract class CodeLensHandler<TData> : ICodeLensHandler<TData>, ICodeLensResolveHandler<TData>
+        where TData : CanBeResolvedData
     {
         private readonly CodeLensRegistrationOptions _options;
+        private readonly Guid _id = Guid.NewGuid();
 
         public CodeLensHandler(CodeLensRegistrationOptions registrationOptions)
         {
@@ -33,259 +36,289 @@ public CodeLensHandler(CodeLensRegistrationOptions registrationOptions)
         }
 
         public CodeLensRegistrationOptions GetRegistrationOptions() => _options;
-        public abstract Task<CodeLensContainer> Handle(CodeLensParams request, CancellationToken cancellationToken);
-        public abstract Task<CodeLens> Handle(CodeLens request, CancellationToken cancellationToken);
-        public abstract bool CanResolve(CodeLens value);
+        public abstract Task<CodeLensContainer<TData>> Handle(CodeLensParams<TData> request, CancellationToken cancellationToken);
+        public abstract Task<CodeLens<TData>> Handle(CodeLens<TData> request, CancellationToken cancellationToken);
         public virtual void SetCapability(CodeLensCapability capability) => Capability = capability;
         protected CodeLensCapability Capability { get; private set; }
+        Guid ICanBeIdentifiedHandler.Id => _id;
     }
 
     public static class CodeLensExtensions
     {
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Func<CodeLensParams, CodeLensCapability, CancellationToken, Task<CodeLensContainer>> handler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Func<CodeLensParams<TData>, CodeLensCapability, CancellationToken, Task<CodeLensContainer<TData>>> handler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.CodeLens,
-                new LanguageProtocolDelegatingHandlers.Request<CodeLensParams, CodeLensContainer, CodeLensCapability,
+                new LanguageProtocolDelegatingHandlers.Request<CodeLensParams<TData>, CodeLensContainer<TData>, CodeLensCapability,
                     CodeLensRegistrationOptions>(
                     handler,
                     registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Func<CodeLensParams, CodeLensCapability, CancellationToken, Task<CodeLensContainer>> handler,
-            Func<CodeLens, bool> canResolve,
-            Func<CodeLens, CodeLensCapability, CancellationToken, Task<CodeLens>> resolveHandler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Func<CodeLensParams<TData>, CodeLensCapability, CancellationToken, Task<CodeLensContainer<TData>>> handler,
+            Func<CodeLens<TData>, CodeLensCapability, CancellationToken, Task<CodeLens<TData>>> resolveHandler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, cap, token) => Task.FromException<CodeLens>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, cap, token) => Task.FromException<CodeLens<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
-            return registry.AddHandler(TextDocumentNames.CodeLens,
-                        new LanguageProtocolDelegatingHandlers.Request<CodeLensParams, CodeLensContainer, CodeLensCapability,
-                            CodeLensRegistrationOptions>(
+            return registry
+                    .AddHandler(TextDocumentNames.CodeLens,
+                        new LanguageProtocolDelegatingHandlers.Request<CodeLensParams<TData>, CodeLensContainer<TData>, CodeLensCapability, CodeLensRegistrationOptions>(
+                            id,
                             handler,
-                            registrationOptions))
+                            registrationOptions)
+                        )
                     .AddHandler(TextDocumentNames.CodeLensResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens, CodeLensCapability, CodeLensRegistrationOptions>(
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens<TData>, CodeLensCapability, CodeLensRegistrationOptions, TData>(
+                            id,
                             resolveHandler,
-                            canResolve,
-                            registrationOptions))
+                            registrationOptions)
+                        )
                 ;
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Func<CodeLensParams, CancellationToken, Task<CodeLensContainer>> handler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Func<CodeLensParams<TData>, CancellationToken, Task<CodeLensContainer<TData>>> handler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.CodeLens,
-                new LanguageProtocolDelegatingHandlers.RequestRegistration<CodeLensParams, CodeLensContainer,
+                new LanguageProtocolDelegatingHandlers.RequestRegistration<CodeLensParams<TData>, CodeLensContainer<TData>,
                     CodeLensRegistrationOptions>(
                     handler,
                     registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Func<CodeLensParams, CancellationToken, Task<CodeLensContainer>> handler,
-            Func<CodeLens, bool> canResolve,
-            Func<CodeLens, CancellationToken, Task<CodeLens>> resolveHandler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Func<CodeLensParams<TData>, CancellationToken, Task<CodeLensContainer<TData>>> handler,
+            Func<CodeLens<TData>, CancellationToken, Task<CodeLens<TData>>> resolveHandler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, token) => Task.FromException<CodeLens>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, token) => Task.FromException<CodeLens<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
-            return registry.AddHandler(TextDocumentNames.CodeLens,
-                        new LanguageProtocolDelegatingHandlers.RequestRegistration<CodeLensParams, CodeLensContainer,
-                            CodeLensRegistrationOptions>(
+            return registry
+                    .AddHandler(TextDocumentNames.CodeLens,
+                        new LanguageProtocolDelegatingHandlers.RequestRegistration<CodeLensParams<TData>, CodeLensContainer<TData>, CodeLensRegistrationOptions>(
+                            id,
                             handler,
-                            registrationOptions))
+                            registrationOptions)
+                        )
                     .AddHandler(TextDocumentNames.CodeLensResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens, CodeLensRegistrationOptions>(
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens<TData>, CodeLensRegistrationOptions, TData>(
+                            id,
                             resolveHandler,
-                            canResolve,
-                            registrationOptions))
+                            registrationOptions)
+                        )
                 ;
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Func<CodeLensParams, Task<CodeLensContainer>> handler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Func<CodeLensParams<TData>, Task<CodeLensContainer<TData>>> handler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.CodeLens,
-                new LanguageProtocolDelegatingHandlers.RequestRegistration<CodeLensParams, CodeLensContainer,
+                new LanguageProtocolDelegatingHandlers.RequestRegistration<CodeLensParams<TData>, CodeLensContainer<TData>,
                     CodeLensRegistrationOptions>(
                     handler,
                     registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Func<CodeLensParams, Task<CodeLensContainer>> handler,
-            Func<CodeLens, bool> canResolve,
-            Func<CodeLens, Task<CodeLens>> resolveHandler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Func<CodeLensParams<TData>, Task<CodeLensContainer<TData>>> handler,
+            Func<CodeLens<TData>, Task<CodeLens<TData>>> resolveHandler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link) => Task.FromException<CodeLens>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link) => Task.FromException<CodeLens<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
-            return registry.AddHandler(TextDocumentNames.CodeLens,
-                        new LanguageProtocolDelegatingHandlers.RequestRegistration<CodeLensParams, CodeLensContainer,
+            return registry
+                    .AddHandler(TextDocumentNames.CodeLens,
+                        new LanguageProtocolDelegatingHandlers.RequestRegistration<CodeLensParams<TData>, CodeLensContainer<TData>,
                             CodeLensRegistrationOptions>(
+                            id,
                             handler,
-                            registrationOptions))
+                            registrationOptions)
+                        )
                     .AddHandler(TextDocumentNames.CodeLensResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens, CodeLensRegistrationOptions>(
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens<TData>, CodeLensRegistrationOptions, TData>(
+                            id,
                             resolveHandler,
-                            canResolve,
-                            registrationOptions))
+                            registrationOptions)
+                        )
                 ;
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Action<CodeLensParams, IObserver<IEnumerable<CodeLens>>, CodeLensCapability, CancellationToken> handler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Action<CodeLensParams<TData>, IObserver<IEnumerable<CodeLens<TData>>>, CodeLensCapability, CancellationToken> handler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.CodeLens,
-                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams, CodeLensContainer, CodeLens, CodeLensCapability,
+                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams<TData>, CodeLensContainer<TData>, CodeLens<TData>, CodeLensCapability,
                     CodeLensRegistrationOptions>(
                     handler,
                     registrationOptions,
                     _.GetRequiredService<IProgressManager>(),
-                    x => new CodeLensContainer(x)));
+                    x => new CodeLensContainer<TData>(x)));
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Action<CodeLensParams, IObserver<IEnumerable<CodeLens>>, CodeLensCapability, CancellationToken> handler,
-            Func<CodeLens, bool> canResolve,
-            Func<CodeLens, CodeLensCapability, CancellationToken, Task<CodeLens>> resolveHandler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Action<CodeLensParams<TData>, IObserver<IEnumerable<CodeLens<TData>>>, CodeLensCapability, CancellationToken> handler,
+            Func<CodeLens<TData>, CodeLensCapability, CancellationToken, Task<CodeLens<TData>>> resolveHandler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, cap, token) => Task.FromException<CodeLens>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, cap, token) => Task.FromException<CodeLens<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return
-                registry.AddHandler(TextDocumentNames.CodeLens,
-                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams, CodeLensContainer, CodeLens, CodeLensCapability,
-                            CodeLensRegistrationOptions>(
+                registry
+                    .AddHandler(TextDocumentNames.CodeLens,
+                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams<TData>, CodeLensContainer<TData>, CodeLens<TData>, CodeLensCapability, CodeLensRegistrationOptions>(
+                            id,
                             handler,
                             registrationOptions,
                             _.GetRequiredService<IProgressManager>(),
-                            x => new CodeLensContainer(x)))
+                            x => new CodeLensContainer<TData>(x))
+                        )
                     .AddHandler(TextDocumentNames.CodeLensResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens, CodeLensCapability, CodeLensRegistrationOptions>(
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens<TData>, CodeLensCapability, CodeLensRegistrationOptions, TData>(
+                            id,
                             resolveHandler,
-                            canResolve,
-                            registrationOptions))
+                            registrationOptions)
+                        )
                 ;
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Action<CodeLensParams, IObserver<IEnumerable<CodeLens>>, CancellationToken> handler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Action<CodeLensParams<TData>, IObserver<IEnumerable<CodeLens<TData>>>, CancellationToken> handler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.CodeLens,
-                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams, CodeLensContainer, CodeLens,
+                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams<TData>, CodeLensContainer<TData>, CodeLens<TData>,
                     CodeLensRegistrationOptions>(
                     handler,
                     registrationOptions,
                     _.GetRequiredService<IProgressManager>(),
-                    x => new CodeLensContainer(x)));
+                    x => new CodeLensContainer<TData>(x)));
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Action<CodeLensParams, IObserver<IEnumerable<CodeLens>>, CancellationToken> handler,
-            Func<CodeLens, bool> canResolve,
-            Func<CodeLens, CancellationToken, Task<CodeLens>> resolveHandler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Action<CodeLensParams<TData>, IObserver<IEnumerable<CodeLens<TData>>>, CancellationToken> handler,
+            Func<CodeLens<TData>, CancellationToken, Task<CodeLens<TData>>> resolveHandler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, token) => Task.FromException<CodeLens>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, token) => Task.FromException<CodeLens<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
-            return registry.AddHandler(TextDocumentNames.CodeLens,
-                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams, CodeLensContainer, CodeLens,
-                            CodeLensRegistrationOptions>(
+            return registry
+                    .AddHandler(TextDocumentNames.CodeLens,
+                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams<TData>, CodeLensContainer<TData>, CodeLens<TData>, CodeLensRegistrationOptions>(
+                            id,
                             handler,
                             registrationOptions,
                             _.GetRequiredService<IProgressManager>(),
-                            x => new CodeLensContainer(x)))
+                            x => new CodeLensContainer<TData>(x))
+                        )
                     .AddHandler(TextDocumentNames.CodeLensResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens, CodeLensRegistrationOptions>(
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens<TData>, CodeLensRegistrationOptions, TData>(
+                            id,
                             resolveHandler,
-                            canResolve,
-                            registrationOptions))
+                            registrationOptions)
+                        )
                 ;
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Action<CodeLensParams, IObserver<IEnumerable<CodeLens>>> handler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Action<CodeLensParams<TData>, IObserver<IEnumerable<CodeLens<TData>>>> handler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.CodeLens,
-                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams, CodeLensContainer, CodeLens,
+                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams<TData>, CodeLensContainer<TData>, CodeLens<TData>,
                     CodeLensRegistrationOptions>(
                     handler,
                     registrationOptions,
                     _.GetRequiredService<IProgressManager>(),
-                    x => new CodeLensContainer(x)));
+                    x => new CodeLensContainer<TData>(x)));
         }
 
-        public static ILanguageServerRegistry OnCodeLens(this ILanguageServerRegistry registry,
-            Action<CodeLensParams, IObserver<IEnumerable<CodeLens>>> handler,
-            Func<CodeLens, bool> canResolve,
-            Func<CodeLens, Task<CodeLens>> resolveHandler,
-            CodeLensRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCodeLens<TData>(this ILanguageServerRegistry registry,
+            Action<CodeLensParams<TData>, IObserver<IEnumerable<CodeLens<TData>>>> handler,
+            Func<CodeLens<TData>, Task<CodeLens<TData>>> resolveHandler,
+            CodeLensRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CodeLensRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link) => Task.FromException<CodeLens>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link) => Task.FromException<CodeLens<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
-            return registry.AddHandler(TextDocumentNames.CodeLens,
-                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams, CodeLensContainer, CodeLens,
-                            CodeLensRegistrationOptions>(
+            return registry
+                    .AddHandler(TextDocumentNames.CodeLens,
+                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<CodeLensParams<TData>, CodeLensContainer<TData>, CodeLens<TData>, CodeLensRegistrationOptions>(
+                            id,
                             handler,
                             registrationOptions,
                             _.GetRequiredService<IProgressManager>(),
-                            x => new CodeLensContainer(x)))
+                            x => new CodeLensContainer<TData>(x))
+                        )
                     .AddHandler(TextDocumentNames.CodeLensResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens, CodeLensRegistrationOptions>(
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<CodeLens<TData>, CodeLensRegistrationOptions, TData>(
+                            id,
                             resolveHandler,
-                            canResolve,
-                            registrationOptions))
+                            registrationOptions)
+                        )
                 ;
         }
 
-        public static IRequestProgressObservable<IEnumerable<CodeLens>, CodeLensContainer> RequestCodeLens(
+        public static IRequestProgressObservable<IEnumerable<CodeLens<ResolvedData>>, CodeLensContainer<ResolvedData>> RequestCodeLens(
             this ITextDocumentLanguageClient mediator,
-            CodeLensParams @params,
+            CodeLensParams<ResolvedData> @params,
             CancellationToken cancellationToken = default)
         {
-            return mediator.ProgressManager.MonitorUntil(@params, x => new CodeLensContainer(x), cancellationToken);
+            return mediator.ProgressManager.MonitorUntil(@params, x => new CodeLensContainer<ResolvedData>(x), cancellationToken);
         }
 
-        public static Task<CodeLens> ResolveCodeLens(this ITextDocumentLanguageClient mediator, CodeLens @params, CancellationToken cancellationToken = default)
+        public static IRequestProgressObservable<IEnumerable<CodeLens<TData>>, CodeLensContainer<TData>> RequestCodeLens<TData>(
+            this ITextDocumentLanguageClient mediator,
+            CodeLensParams<TData> @params,
+            CancellationToken cancellationToken = default)
+            where TData : CanBeResolvedData
+        {
+            return mediator.ProgressManager.MonitorUntil(@params, x => new CodeLensContainer<TData>(x), cancellationToken);
+        }
+
+        public static Task<CodeLens<ResolvedData>> ResolveCodeLens(this ITextDocumentLanguageClient mediator, CodeLens<ResolvedData> @params,
+            CancellationToken cancellationToken = default)
+        {
+            return mediator.SendRequest(@params, cancellationToken);
+        }
+
+        public static Task<CodeLens<TData>> ResolveCodeLens<TData>(this ITextDocumentLanguageClient mediator, CodeLens<TData> @params,
+            CancellationToken cancellationToken = default)
+            where TData : CanBeResolvedData
         {
             return mediator.SendRequest(@params, cancellationToken);
         }
diff --git a/src/Protocol/Document/ICompletionHandler.cs b/src/Protocol/Document/ICompletionHandler.cs
index 0131434b7..3ae08d1a6 100644
--- a/src/Protocol/Document/ICompletionHandler.cs
+++ b/src/Protocol/Document/ICompletionHandler.cs
@@ -4,6 +4,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
+using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.JsonRpc;
 using OmniSharp.Extensions.LanguageServer.Protocol.Client;
 using OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities;
@@ -14,18 +15,20 @@
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Document
 {
     [Parallel, Method(TextDocumentNames.Completion, Direction.ClientToServer)]
-    public interface ICompletionHandler : IJsonRpcRequestHandler<CompletionParams, CompletionList>, IRegistration<CompletionRegistrationOptions>, ICapability<CompletionCapability>
+    public interface ICompletionHandler<TData> : IJsonRpcRequestHandler<CompletionParams<TData>, CompletionList<TData>>, IRegistration<CompletionRegistrationOptions>,
+        ICapability<CompletionCapability> where TData : CanBeResolvedData
     {
     }
 
     [Parallel, Method(TextDocumentNames.CompletionResolve, Direction.ClientToServer)]
-    public interface ICompletionResolveHandler : ICanBeResolvedHandler<CompletionItem>
+    public interface ICompletionResolveHandler<TData> : ICanBeResolvedHandler<CompletionItem<TData>, TData> where TData : CanBeResolvedData
     {
     }
 
-    public abstract class CompletionHandler : ICompletionHandler, ICompletionResolveHandler
+    public abstract class CompletionHandler<TData> : ICompletionHandler<TData>, ICompletionResolveHandler<TData> where TData : CanBeResolvedData
     {
         private readonly CompletionRegistrationOptions _options;
+        private readonly Guid _id = Guid.NewGuid();
 
         public CompletionHandler(CompletionRegistrationOptions registrationOptions)
         {
@@ -33,258 +36,269 @@ public CompletionHandler(CompletionRegistrationOptions registrationOptions)
         }
 
         public CompletionRegistrationOptions GetRegistrationOptions() => _options;
-        public abstract Task<CompletionList> Handle(CompletionParams request, CancellationToken cancellationToken);
-        public abstract Task<CompletionItem> Handle(CompletionItem request, CancellationToken cancellationToken);
-        public abstract bool CanResolve(CompletionItem value);
+        public abstract Task<CompletionList<TData>> Handle(CompletionParams<TData> request, CancellationToken cancellationToken);
+        public abstract Task<CompletionItem<TData>> Handle(CompletionItem<TData> request, CancellationToken cancellationToken);
         public virtual void SetCapability(CompletionCapability capability) => Capability = capability;
         protected CompletionCapability Capability { get; private set; }
+        Guid ICanBeIdentifiedHandler.Id => _id;
     }
 
     public static class CompletionExtensions
     {
-        public static ILanguageServerRegistry OnCompletion(
+        public static ILanguageServerRegistry OnCompletion<TData>(
             this ILanguageServerRegistry registry,
-            Func<CompletionParams, CompletionCapability, CancellationToken, Task<CompletionList>> handler,
-            CompletionRegistrationOptions registrationOptions)
+            Func<CompletionParams<TData>, CompletionCapability, CancellationToken, Task<CompletionList<TData>>> handler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.Completion,
-                new LanguageProtocolDelegatingHandlers.Request<CompletionParams, CompletionList, CompletionCapability,
+                new LanguageProtocolDelegatingHandlers.Request<CompletionParams<TData>, CompletionList<TData>, CompletionCapability,
                     CompletionRegistrationOptions>(
                     handler,
                     registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCompletion(
+        public static ILanguageServerRegistry OnCompletion<TData>(
             this ILanguageServerRegistry registry,
-            Func<CompletionParams, CompletionCapability, CancellationToken, Task<CompletionList>> handler,
-            Func<CompletionItem, bool> canResolve,
-            Func<CompletionItem, CompletionCapability, CancellationToken, Task<CompletionItem>> resolveHandler,
-            CompletionRegistrationOptions registrationOptions)
+            Func<CompletionParams<TData>, CompletionCapability, CancellationToken, Task<CompletionList<TData>>> handler,
+            Func<CompletionItem<TData>, CompletionCapability, CancellationToken, Task<CompletionItem<TData>>> resolveHandler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, cap, token) => Task.FromException<CompletionItem>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, cap, token) => Task.FromException<CompletionItem<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry
                 .AddHandler(TextDocumentNames.Completion,
-                    new LanguageProtocolDelegatingHandlers.Request<CompletionParams, CompletionList, CompletionCapability,
-                        CompletionRegistrationOptions>(
+                    new LanguageProtocolDelegatingHandlers.Request<CompletionParams<TData>, CompletionList<TData>, CompletionCapability, CompletionRegistrationOptions>(
+                        id,
                         handler,
                         registrationOptions)
                 )
                 .AddHandler(TextDocumentNames.CompletionResolve,
-                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem, CompletionCapability, CompletionRegistrationOptions>(
+                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem<TData>, CompletionCapability, CompletionRegistrationOptions, TData>(
+                        id,
                         resolveHandler,
-                        canResolve,
                         registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCompletion(this ILanguageServerRegistry registry,
-            Func<CompletionParams, CancellationToken, Task<CompletionList>> handler,
-            CompletionRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCompletion<TData>(this ILanguageServerRegistry registry,
+            Func<CompletionParams<TData>, CancellationToken, Task<CompletionList<TData>>> handler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.Completion,
-                new LanguageProtocolDelegatingHandlers.RequestRegistration<CompletionParams, CompletionList,
+                new LanguageProtocolDelegatingHandlers.RequestRegistration<CompletionParams<TData>, CompletionList<TData>,
                     CompletionRegistrationOptions>(
                     handler,
                     registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCompletion(this ILanguageServerRegistry registry,
-            Func<CompletionParams, CancellationToken, Task<CompletionList>> handler,
-            Func<CompletionItem, bool> canResolve,
-            Func<CompletionItem, CancellationToken, Task<CompletionItem>> resolveHandler,
-            CompletionRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCompletion<TData>(this ILanguageServerRegistry registry,
+            Func<CompletionParams<TData>, CancellationToken, Task<CompletionList<TData>>> handler,
+            Func<CompletionItem<TData>, CancellationToken, Task<CompletionItem<TData>>> resolveHandler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, token) => Task.FromException<CompletionItem>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, token) => Task.FromException<CompletionItem<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry
                 .AddHandler(TextDocumentNames.Completion,
-                    new LanguageProtocolDelegatingHandlers.RequestRegistration<CompletionParams, CompletionList,
-                        CompletionRegistrationOptions>(
+                    new LanguageProtocolDelegatingHandlers.RequestRegistration<CompletionParams<TData>, CompletionList<TData>, CompletionRegistrationOptions>(
+                        id,
                         handler,
                         registrationOptions))
                 .AddHandler(TextDocumentNames.CompletionResolve,
-                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem, CompletionRegistrationOptions>(
+                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem<TData>, CompletionRegistrationOptions, TData>(
+                        id,
                         resolveHandler,
-                        canResolve,
                         registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCompletion(this ILanguageServerRegistry registry,
-            Func<CompletionParams, Task<CompletionList>> handler,
-            CompletionRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCompletion<TData>(this ILanguageServerRegistry registry,
+            Func<CompletionParams<TData>, Task<CompletionList<TData>>> handler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.Completion,
-                new LanguageProtocolDelegatingHandlers.RequestRegistration<CompletionParams, CompletionList,
+                new LanguageProtocolDelegatingHandlers.RequestRegistration<CompletionParams<TData>, CompletionList<TData>,
                     CompletionRegistrationOptions>(
                     handler,
                     registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCompletion(this ILanguageServerRegistry registry,
-            Func<CompletionParams, Task<CompletionList>> handler,
-            Func<CompletionItem, bool> canResolve,
-            Func<CompletionItem, Task<CompletionItem>> resolveHandler,
-            CompletionRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCompletion<TData>(this ILanguageServerRegistry registry,
+            Func<CompletionParams<TData>, Task<CompletionList<TData>>> handler,
+            Func<CompletionItem<TData>, Task<CompletionItem<TData>>> resolveHandler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link) => Task.FromException<CompletionItem>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link) => Task.FromException<CompletionItem<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry
                 .AddHandler(TextDocumentNames.Completion,
-                    new LanguageProtocolDelegatingHandlers.RequestRegistration<CompletionParams, CompletionList,
-                        CompletionRegistrationOptions>(
+                    new LanguageProtocolDelegatingHandlers.RequestRegistration<CompletionParams<TData>, CompletionList<TData>, CompletionRegistrationOptions>(
+                        id,
                         handler,
                         registrationOptions)
                 )
                 .AddHandler(TextDocumentNames.CompletionResolve,
-                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem, CompletionRegistrationOptions>(
+                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem<TData>, CompletionRegistrationOptions, TData>(
+                        id,
                         resolveHandler,
-                        canResolve,
                         registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCompletion(this ILanguageServerRegistry registry,
-            Action<CompletionParams, IObserver<IEnumerable<CompletionItem>>, CompletionCapability, CancellationToken> handler,
-            CompletionRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCompletion<TData>(this ILanguageServerRegistry registry,
+            Action<CompletionParams<TData>, IObserver<IEnumerable<CompletionItem<TData>>>, CompletionCapability, CancellationToken> handler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.Completion,
-                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams, CompletionList, CompletionItem, CompletionCapability,
+                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams<TData>, CompletionList<TData>, CompletionItem<TData>, CompletionCapability,
                     CompletionRegistrationOptions>(
                     handler,
                     registrationOptions,
                     _.GetRequiredService<IProgressManager>(),
-                    x => new CompletionList(x)));
+                    x => new CompletionList<TData>(x)));
         }
 
-        public static ILanguageServerRegistry OnCompletion(this ILanguageServerRegistry registry,
-            Action<CompletionParams, IObserver<IEnumerable<CompletionItem>>, CompletionCapability, CancellationToken> handler,
-            Func<CompletionItem, bool> canResolve,
-            Func<CompletionItem, CompletionCapability, CancellationToken, Task<CompletionItem>> resolveHandler,
-            CompletionRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCompletion<TData>(this ILanguageServerRegistry registry,
+            Action<CompletionParams<TData>, IObserver<IEnumerable<CompletionItem<TData>>>, CompletionCapability, CancellationToken> handler,
+            Func<CompletionItem<TData>, CompletionCapability, CancellationToken, Task<CompletionItem<TData>>> resolveHandler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, cap, token) => Task.FromException<CompletionItem>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, cap, token) => Task.FromException<CompletionItem<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry.AddHandler(TextDocumentNames.Completion,
-                    _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams, CompletionList, CompletionItem, CompletionCapability,
-                        CompletionRegistrationOptions>(
+                    _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams<TData>, CompletionList<TData>, CompletionItem<TData>, CompletionCapability, CompletionRegistrationOptions>(
+                        id,
                         handler,
                         registrationOptions,
                         _.GetRequiredService<IProgressManager>(),
-                        x => new CompletionList(x))
+                        x => new CompletionList<TData>(x))
                 )
                 .AddHandler(TextDocumentNames.CompletionResolve,
-                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem, CompletionCapability, CompletionRegistrationOptions>(
+                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem<TData>, CompletionCapability, CompletionRegistrationOptions, TData>(
+                        id,
                         resolveHandler,
-                        canResolve,
                         registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCompletion(this ILanguageServerRegistry registry,
-            Action<CompletionParams, IObserver<IEnumerable<CompletionItem>>, CancellationToken> handler,
-            CompletionRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCompletion<TData>(this ILanguageServerRegistry registry,
+            Action<CompletionParams<TData>, IObserver<IEnumerable<CompletionItem<TData>>>, CancellationToken> handler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.Completion,
-                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams, CompletionList, CompletionItem,
-                    CompletionRegistrationOptions>(
+                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams<TData>, CompletionList<TData>, CompletionItem<TData>, CompletionRegistrationOptions>(
                     handler,
                     registrationOptions,
                     _.GetRequiredService<IProgressManager>(),
-                    x => new CompletionList(x)));
+                    x => new CompletionList<TData>(x)));
         }
 
-        public static ILanguageServerRegistry OnCompletion(this ILanguageServerRegistry registry,
-            Action<CompletionParams, IObserver<IEnumerable<CompletionItem>>, CancellationToken> handler,
-            Func<CompletionItem, bool> canResolve,
-            Func<CompletionItem, CancellationToken, Task<CompletionItem>> resolveHandler,
-            CompletionRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCompletion<TData>(this ILanguageServerRegistry registry,
+            Action<CompletionParams<TData>, IObserver<IEnumerable<CompletionItem<TData>>>, CancellationToken> handler,
+            Func<CompletionItem<TData>, CancellationToken, Task<CompletionItem<TData>>> resolveHandler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, token) => Task.FromException<CompletionItem>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, token) => Task.FromException<CompletionItem<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry.AddHandler(TextDocumentNames.Completion,
-                    _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams, CompletionList, CompletionItem,
-                        CompletionRegistrationOptions>(
+                    _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams<TData>, CompletionList<TData>, CompletionItem<TData>, CompletionRegistrationOptions>(
+                        id,
                         handler,
                         registrationOptions,
                         _.GetRequiredService<IProgressManager>(),
-                        x => new CompletionList(x)))
+                        x => new CompletionList<TData>(x)))
                 .AddHandler(TextDocumentNames.CompletionResolve,
-                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem, CompletionRegistrationOptions>(
+                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem<TData>, CompletionRegistrationOptions, TData>(
+                        id,
                         resolveHandler,
-                        canResolve,
                         registrationOptions));
         }
 
-        public static ILanguageServerRegistry OnCompletion(this ILanguageServerRegistry registry,
-            Action<CompletionParams, IObserver<IEnumerable<CompletionItem>>> handler,
-            CompletionRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCompletion<TData>(this ILanguageServerRegistry registry,
+            Action<CompletionParams<TData>, IObserver<IEnumerable<CompletionItem<TData>>>> handler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.Completion,
-                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams, CompletionList, CompletionItem,
+                _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams<TData>, CompletionList<TData>, CompletionItem<TData>,
                     CompletionRegistrationOptions>(
                     handler,
                     registrationOptions,
                     _.GetRequiredService<IProgressManager>(),
-                    x => new CompletionList(x)));
+                    x => new CompletionList<TData>(x)));
         }
 
-        public static ILanguageServerRegistry OnCompletion(this ILanguageServerRegistry registry,
-            Action<CompletionParams, IObserver<IEnumerable<CompletionItem>>> handler,
-            Func<CompletionItem, bool> canResolve,
-            Func<CompletionItem, Task<CompletionItem>> resolveHandler,
-            CompletionRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnCompletion<TData>(this ILanguageServerRegistry registry,
+            Action<CompletionParams<TData>, IObserver<IEnumerable<CompletionItem<TData>>>> handler,
+            Func<CompletionItem<TData>, Task<CompletionItem<TData>>> resolveHandler,
+            CompletionRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new CompletionRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link) => Task.FromException<CompletionItem>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link) => Task.FromException<CompletionItem<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry.AddHandler(TextDocumentNames.Completion,
-                    _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams, CompletionList, CompletionItem,
+                    _ => new LanguageProtocolDelegatingHandlers.PartialResults<CompletionParams<TData>, CompletionList<TData>, CompletionItem<TData>,
                         CompletionRegistrationOptions>(
+                        id,
                         handler,
                         registrationOptions,
                         _.GetRequiredService<IProgressManager>(),
-                        x => new CompletionList(x)))
+                        x => new CompletionList<TData>(x)))
                 .AddHandler(TextDocumentNames.CompletionResolve,
-                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem, CompletionRegistrationOptions>(
+                    new LanguageProtocolDelegatingHandlers.CanBeResolved<CompletionItem<TData>, CompletionRegistrationOptions, TData>(
+                        id,
                         resolveHandler,
-                        canResolve,
                         registrationOptions));
         }
 
-        public static IRequestProgressObservable<IEnumerable<CompletionItem>, CompletionList> RequestCompletion(this ITextDocumentLanguageClient mediator, CompletionParams @params,
+        public static IRequestProgressObservable<IEnumerable<CompletionItem<ResolvedData>>, CompletionList<ResolvedData>> RequestCompletion(
+            this ITextDocumentLanguageClient mediator, CompletionParams<ResolvedData> @params,
+            CancellationToken cancellationToken = default)
+        {
+            return mediator.ProgressManager.MonitorUntil(@params, x => new CompletionList<ResolvedData>(x), cancellationToken);
+        }
+
+        public static Task<CompletionItem<ResolvedData>> ResolveCompletion(this ITextDocumentLanguageClient mediator, CompletionItem<ResolvedData> @params,
+            CancellationToken cancellationToken = default)
+        {
+            return mediator.SendRequest(@params, cancellationToken);
+        }
+
+        public static IRequestProgressObservable<IEnumerable<CompletionItem<TData>>, CompletionList<TData>> RequestCompletion<TData>(this ITextDocumentLanguageClient mediator,
+            CompletionParams<TData> @params,
             CancellationToken cancellationToken = default)
+            where TData : CanBeResolvedData
         {
-            return mediator.ProgressManager.MonitorUntil(@params, x => new CompletionList(x), cancellationToken);
+            return mediator.ProgressManager.MonitorUntil(@params, x => new CompletionList<TData>(x), cancellationToken);
         }
 
-        public static Task<CompletionItem> ResolveCompletion(this ITextDocumentLanguageClient mediator, CompletionItem @params, CancellationToken cancellationToken = default)
+        public static Task<CompletionItem<TData>> ResolveCompletion<TData>(this ITextDocumentLanguageClient mediator, CompletionItem<TData> @params,
+            CancellationToken cancellationToken = default)
+            where TData : CanBeResolvedData
         {
             return mediator.SendRequest(@params, cancellationToken);
         }
diff --git a/src/Protocol/Document/IDocumentLinkHandler.cs b/src/Protocol/Document/IDocumentLinkHandler.cs
index dbf84fdce..10ff48cab 100644
--- a/src/Protocol/Document/IDocumentLinkHandler.cs
+++ b/src/Protocol/Document/IDocumentLinkHandler.cs
@@ -14,19 +14,20 @@
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Document
 {
     [Parallel, Method(TextDocumentNames.DocumentLink, Direction.ClientToServer)]
-    public interface IDocumentLinkHandler : IJsonRpcRequestHandler<DocumentLinkParams, DocumentLinkContainer>,
-        IRegistration<DocumentLinkRegistrationOptions>, ICapability<DocumentLinkCapability>
+    public interface IDocumentLinkHandler<TData> : IJsonRpcRequestHandler<DocumentLinkParams<TData>, DocumentLinkContainer<TData>>,
+        IRegistration<DocumentLinkRegistrationOptions>, ICapability<DocumentLinkCapability> where TData : CanBeResolvedData
     {
     }
 
     [Parallel, Method(TextDocumentNames.DocumentLinkResolve, Direction.ClientToServer)]
-    public interface IDocumentLinkResolveHandler : ICanBeResolvedHandler<DocumentLink>
+    public interface IDocumentLinkResolveHandler<TData> : ICanBeResolvedHandler<DocumentLink<TData>, TData> where TData : CanBeResolvedData
     {
     }
 
-    public abstract class DocumentLinkHandler : IDocumentLinkHandler, IDocumentLinkResolveHandler
+    public abstract class DocumentLinkHandler<TData> : IDocumentLinkHandler<TData>, IDocumentLinkResolveHandler<TData> where TData : CanBeResolvedData
     {
         private readonly DocumentLinkRegistrationOptions _options;
+        private readonly Guid _id = Guid.NewGuid();
 
         public DocumentLinkHandler(DocumentLinkRegistrationOptions registrationOptions)
         {
@@ -35,257 +36,275 @@ public DocumentLinkHandler(DocumentLinkRegistrationOptions registrationOptions)
 
         public DocumentLinkRegistrationOptions GetRegistrationOptions() => _options;
 
-        public abstract Task<DocumentLinkContainer> Handle(DocumentLinkParams request, CancellationToken cancellationToken);
+        public abstract Task<DocumentLinkContainer<TData>> Handle(DocumentLinkParams<TData> request, CancellationToken cancellationToken);
 
-        public abstract Task<DocumentLink> Handle(DocumentLink request, CancellationToken cancellationToken);
-        public abstract bool CanResolve(DocumentLink value);
+        public abstract Task<DocumentLink<TData>> Handle(DocumentLink<TData> request, CancellationToken cancellationToken);
         public virtual void SetCapability(DocumentLinkCapability capability) => Capability = capability;
         protected DocumentLinkCapability Capability { get; private set; }
+        Guid ICanBeIdentifiedHandler.Id => _id;
     }
 
     public static class DocumentLinkExtensions
     {
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Func<DocumentLinkParams, DocumentLinkCapability, CancellationToken, Task<DocumentLinkContainer>> handler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Func<DocumentLinkParams<TData>, DocumentLinkCapability, CancellationToken, Task<DocumentLinkContainer<TData>>> handler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                new LanguageProtocolDelegatingHandlers.Request<DocumentLinkParams, DocumentLinkContainer, DocumentLinkCapability,
+                new LanguageProtocolDelegatingHandlers.Request<DocumentLinkParams<TData>, DocumentLinkContainer<TData>, DocumentLinkCapability,
                     DocumentLinkRegistrationOptions>(
                     handler,
                     registrationOptions));
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Func<DocumentLinkParams, DocumentLinkCapability, CancellationToken, Task<DocumentLinkContainer>> handler,
-            Func<DocumentLink, bool> canResolve,
-            Func<DocumentLink, DocumentLinkCapability, CancellationToken, Task<DocumentLink>> resolveHandler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Func<DocumentLinkParams<TData>, DocumentLinkCapability, CancellationToken, Task<DocumentLinkContainer<TData>>> handler,
+            Func<DocumentLink<TData>, DocumentLinkCapability, CancellationToken, Task<DocumentLink<TData>>> resolveHandler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, cap, token) => Task.FromException<DocumentLink>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, cap, token) => Task.FromException<DocumentLink<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                        new LanguageProtocolDelegatingHandlers.Request<DocumentLinkParams, DocumentLinkContainer, DocumentLinkCapability,
+                        new LanguageProtocolDelegatingHandlers.Request<DocumentLinkParams<TData>, DocumentLinkContainer<TData>, DocumentLinkCapability,
                             DocumentLinkRegistrationOptions>(
+                            id,
                             handler,
                             registrationOptions))
                     .AddHandler(TextDocumentNames.DocumentLinkResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink, DocumentLinkCapability, DocumentLinkRegistrationOptions>(
-                            resolveHandler,
-                            canResolve,
-                            registrationOptions))
-                ;
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink<TData>, DocumentLinkCapability, DocumentLinkRegistrationOptions, TData>(
+                            id,
+                            resolveHandler, registrationOptions
+                        ));
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Func<DocumentLinkParams, CancellationToken, Task<DocumentLinkContainer>> handler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Func<DocumentLinkParams<TData>, CancellationToken, Task<DocumentLinkContainer<TData>>> handler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                new LanguageProtocolDelegatingHandlers.RequestRegistration<DocumentLinkParams, DocumentLinkContainer,
+                new LanguageProtocolDelegatingHandlers.RequestRegistration<DocumentLinkParams<TData>, DocumentLinkContainer<TData>,
                     DocumentLinkRegistrationOptions>(
                     handler,
                     registrationOptions));
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Func<DocumentLinkParams, CancellationToken, Task<DocumentLinkContainer>> handler,
-            Func<DocumentLink, bool> canResolve,
-            Func<DocumentLink, CancellationToken, Task<DocumentLink>> resolveHandler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Func<DocumentLinkParams<TData>, CancellationToken, Task<DocumentLinkContainer<TData>>> handler,
+            Func<DocumentLink<TData>, CancellationToken, Task<DocumentLink<TData>>> resolveHandler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, token) => Task.FromException<DocumentLink>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, token) => Task.FromException<DocumentLink<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                    new LanguageProtocolDelegatingHandlers.RequestRegistration<DocumentLinkParams, DocumentLinkContainer,
+                    new LanguageProtocolDelegatingHandlers.RequestRegistration<DocumentLinkParams<TData>, DocumentLinkContainer<TData>,
                         DocumentLinkRegistrationOptions>(
+                        id,
                         handler,
                         registrationOptions)).AddHandler(TextDocumentNames.DocumentLinkResolve,
-                    new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink, DocumentLinkRegistrationOptions>(
+                    new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink<TData>, DocumentLinkRegistrationOptions, TData>(
+                        id,
                         resolveHandler,
-                        canResolve,
                         registrationOptions))
                 ;
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Func<DocumentLinkParams, Task<DocumentLinkContainer>> handler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Func<DocumentLinkParams<TData>, Task<DocumentLinkContainer<TData>>> handler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                new LanguageProtocolDelegatingHandlers.RequestRegistration<DocumentLinkParams, DocumentLinkContainer,
+                new LanguageProtocolDelegatingHandlers.RequestRegistration<DocumentLinkParams<TData>, DocumentLinkContainer<TData>,
                     DocumentLinkRegistrationOptions>(
                     handler,
                     registrationOptions));
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Func<DocumentLinkParams, Task<DocumentLinkContainer>> handler,
-            Func<DocumentLink, bool> canResolve,
-            Func<DocumentLink, Task<DocumentLink>> resolveHandler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Func<DocumentLinkParams<TData>, Task<DocumentLinkContainer<TData>>> handler,
+            Func<DocumentLink<TData>, Task<DocumentLink<TData>>> resolveHandler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link) => Task.FromException<DocumentLink>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link) => Task.FromException<DocumentLink<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                        new LanguageProtocolDelegatingHandlers.RequestRegistration<DocumentLinkParams, DocumentLinkContainer,
+                        new LanguageProtocolDelegatingHandlers.RequestRegistration<DocumentLinkParams<TData>, DocumentLinkContainer<TData>,
                             DocumentLinkRegistrationOptions>(
+                            id,
                             handler,
                             registrationOptions))
                     .AddHandler(TextDocumentNames.DocumentLinkResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink, DocumentLinkRegistrationOptions>(
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink<TData>, DocumentLinkRegistrationOptions, TData>(
+                            id,
                             resolveHandler,
-                            canResolve,
                             registrationOptions))
                 ;
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Action<DocumentLinkParams, IObserver<IEnumerable<DocumentLink>>, DocumentLinkCapability, CancellationToken> handler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Action<DocumentLinkParams<TData>, IObserver<IEnumerable<DocumentLink<TData>>>, DocumentLinkCapability, CancellationToken> handler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams, DocumentLinkContainer, DocumentLink, DocumentLinkCapability,
+                _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams<TData>, DocumentLinkContainer<TData>, DocumentLink<TData>, DocumentLinkCapability,
                     DocumentLinkRegistrationOptions>(
                     handler,
                     registrationOptions,
                     _.GetRequiredService<IProgressManager>(),
-                    x => new DocumentLinkContainer(x)));
+                    x => new DocumentLinkContainer<TData>(x)));
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Action<DocumentLinkParams, IObserver<IEnumerable<DocumentLink>>, DocumentLinkCapability, CancellationToken> handler,
-            Func<DocumentLink, bool> canResolve,
-            Func<DocumentLink, DocumentLinkCapability, CancellationToken, Task<DocumentLink>> resolveHandler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Action<DocumentLinkParams<TData>, IObserver<IEnumerable<DocumentLink<TData>>>, DocumentLinkCapability, CancellationToken> handler,
+            Func<DocumentLink<TData>, DocumentLinkCapability, CancellationToken, Task<DocumentLink<TData>>> resolveHandler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, cap, token) => Task.FromException<DocumentLink>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, cap, token) => Task.FromException<DocumentLink<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams, DocumentLinkContainer, DocumentLink, DocumentLinkCapability,
+                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams<TData>, DocumentLinkContainer<TData>, DocumentLink<TData>,
+                            DocumentLinkCapability,
                             DocumentLinkRegistrationOptions>(
+                            id,
                             handler,
                             registrationOptions,
                             _.GetRequiredService<IProgressManager>(),
-                            x => new DocumentLinkContainer(x)))
+                            x => new DocumentLinkContainer<TData>(x)))
                     .AddHandler(TextDocumentNames.DocumentLinkResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink, DocumentLinkCapability, DocumentLinkRegistrationOptions>(
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink<TData>, DocumentLinkCapability, DocumentLinkRegistrationOptions, TData>(
+                            id,
                             resolveHandler,
-                            canResolve,
                             registrationOptions))
                 ;
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Action<DocumentLinkParams, IObserver<IEnumerable<DocumentLink>>, CancellationToken> handler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Action<DocumentLinkParams<TData>, IObserver<IEnumerable<DocumentLink<TData>>>, CancellationToken> handler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams, DocumentLinkContainer, DocumentLink,
+                _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams<TData>, DocumentLinkContainer<TData>, DocumentLink<TData>,
                     DocumentLinkRegistrationOptions>(
                     handler,
                     registrationOptions,
                     _.GetRequiredService<IProgressManager>(),
-                    x => new DocumentLinkContainer(x)));
+                    x => new DocumentLinkContainer<TData>(x)));
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Action<DocumentLinkParams, IObserver<IEnumerable<DocumentLink>>, CancellationToken> handler,
-            Func<DocumentLink, bool> canResolve,
-            Func<DocumentLink, CancellationToken, Task<DocumentLink>> resolveHandler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Action<DocumentLinkParams<TData>, IObserver<IEnumerable<DocumentLink<TData>>>, CancellationToken> handler,
+            Func<DocumentLink<TData>, CancellationToken, Task<DocumentLink<TData>>> resolveHandler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link, token) => Task.FromException<DocumentLink>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link, token) => Task.FromException<DocumentLink<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams, DocumentLinkContainer, DocumentLink,
+                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams<TData>, DocumentLinkContainer<TData>, DocumentLink<TData>,
                             DocumentLinkRegistrationOptions>(
+                            id,
                             handler,
                             registrationOptions,
                             _.GetRequiredService<IProgressManager>(),
-                            x => new DocumentLinkContainer(x)))
+                            x => new DocumentLinkContainer<TData>(x)))
                     .AddHandler(TextDocumentNames.DocumentLinkResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink, DocumentLinkRegistrationOptions>(
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink<TData>, DocumentLinkRegistrationOptions, TData>(
+                            id,
                             resolveHandler,
-                            canResolve,
                             registrationOptions))
                 ;
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Action<DocumentLinkParams, IObserver<IEnumerable<DocumentLink>>> handler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Action<DocumentLinkParams<TData>, IObserver<IEnumerable<DocumentLink<TData>>>> handler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams, DocumentLinkContainer, DocumentLink,
+                _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams<TData>, DocumentLinkContainer<TData>, DocumentLink<TData>,
                     DocumentLinkRegistrationOptions>(
                     handler,
                     registrationOptions,
                     _.GetRequiredService<IProgressManager>(),
-                    x => new DocumentLinkContainer(x)));
+                    x => new DocumentLinkContainer<TData>(x)));
         }
 
-public static ILanguageServerRegistry OnDocumentLink(this ILanguageServerRegistry registry,
-            Action<DocumentLinkParams, IObserver<IEnumerable<DocumentLink>>> handler,
-            Func<DocumentLink, bool> canResolve,
-            Func<DocumentLink, Task<DocumentLink>> resolveHandler,
-            DocumentLinkRegistrationOptions registrationOptions)
+        public static ILanguageServerRegistry OnDocumentLink<TData>(this ILanguageServerRegistry registry,
+            Action<DocumentLinkParams<TData>, IObserver<IEnumerable<DocumentLink<TData>>>> handler,
+            Func<DocumentLink<TData>, Task<DocumentLink<TData>>> resolveHandler,
+            DocumentLinkRegistrationOptions registrationOptions) where TData : CanBeResolvedData
         {
             registrationOptions ??= new DocumentLinkRegistrationOptions();
-            registrationOptions.ResolveProvider = canResolve != null && resolveHandler != null;
-            canResolve ??= item => registrationOptions.ResolveProvider;
-            resolveHandler ??= (link) => Task.FromException<DocumentLink>(new NotImplementedException());
+            registrationOptions.ResolveProvider = resolveHandler != null;
+            resolveHandler ??= (link) => Task.FromException<DocumentLink<TData>>(new NotImplementedException());
+            var id = Guid.NewGuid();
 
             return registry.AddHandler(TextDocumentNames.DocumentLink,
-                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams, DocumentLinkContainer, DocumentLink,
+                        _ => new LanguageProtocolDelegatingHandlers.PartialResults<DocumentLinkParams<TData>, DocumentLinkContainer<TData>, DocumentLink<TData>,
                             DocumentLinkRegistrationOptions>(
+                            id,
                             handler,
                             registrationOptions,
                             _.GetRequiredService<IProgressManager>(),
-                            x => new DocumentLinkContainer(x)))
+                            x => new DocumentLinkContainer<TData>(x)))
                     .AddHandler(TextDocumentNames.DocumentLinkResolve,
-                        new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink, DocumentLinkRegistrationOptions>(
+                        new LanguageProtocolDelegatingHandlers.CanBeResolved<DocumentLink<TData>, DocumentLinkRegistrationOptions, TData>(
+                            id,
                             resolveHandler,
-                            canResolve,
                             registrationOptions))
                 ;
         }
 
-        public static IRequestProgressObservable<IEnumerable<DocumentLink>, DocumentLinkContainer> RequestDocumentLink(this ITextDocumentLanguageClient mediator,
-            DocumentLinkParams @params,
+        public static IRequestProgressObservable<IEnumerable<DocumentLink<ResolvedData>>, DocumentLinkContainer<ResolvedData>> RequestDocumentLink(
+            this ITextDocumentLanguageClient mediator,
+            DocumentLinkParams<ResolvedData> @params,
             CancellationToken cancellationToken = default)
         {
-            return mediator.ProgressManager.MonitorUntil(@params, x => new DocumentLinkContainer(x), cancellationToken);
+            return mediator.ProgressManager.MonitorUntil(@params, x => new DocumentLinkContainer<ResolvedData>(x), cancellationToken);
         }
 
-        public static Task<DocumentLink> ResolveDocumentLink(this ITextDocumentLanguageClient mediator, DocumentLink @params, CancellationToken cancellationToken = default)
+        public static Task<DocumentLink<ResolvedData>> ResolveDocumentLink(this ITextDocumentLanguageClient mediator, DocumentLink<ResolvedData> @params,
+            CancellationToken cancellationToken = default)
+        {
+            return mediator.SendRequest(@params, cancellationToken);
+        }
+
+        public static IRequestProgressObservable<IEnumerable<DocumentLink<TData>>, DocumentLinkContainer<TData>> RequestDocumentLink<TData>(
+            this ITextDocumentLanguageClient mediator,
+            DocumentLinkParams<TData> @params,
+            CancellationToken cancellationToken = default)
+            where TData : CanBeResolvedData
+        {
+            return mediator.ProgressManager.MonitorUntil(@params, x => new DocumentLinkContainer<TData>(x), cancellationToken);
+        }
+
+        public static Task<DocumentLink<TData>> ResolveDocumentLink<TData>(this ITextDocumentLanguageClient mediator, DocumentLink<TData> @params,
+            CancellationToken cancellationToken = default)
+            where TData : CanBeResolvedData
         {
             return mediator.SendRequest(@params, cancellationToken);
         }
diff --git a/src/Protocol/Document/ITextDocumentIdentifier.cs b/src/Protocol/Document/ITextDocumentIdentifier.cs
index fdcf61ea8..c17bec66e 100644
--- a/src/Protocol/Document/ITextDocumentIdentifier.cs
+++ b/src/Protocol/Document/ITextDocumentIdentifier.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reactive.Disposables;
+using Minimatch;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Document
 {
@@ -12,20 +14,104 @@ public interface ITextDocumentIdentifier
         /// </summary>
         /// <param name="uri"></param>
         /// <returns></returns>
-        TextDocumentAttributes GetTextDocumentAttributes(DocumentUri uri);
+        IEnumerable<TextDocumentAttributes> GetTextDocumentAttributes(DocumentUri uri);
     }
 
     public abstract class TextDocumentIdentifierBase : ITextDocumentIdentifier
     {
-        public TextDocumentAttributes GetTextDocumentAttributes(DocumentUri uri)
+        public IEnumerable<TextDocumentAttributes> GetTextDocumentAttributes(DocumentUri uri)
         {
-            var (languageId, schema) = GetAttributes(uri);
-            return new TextDocumentAttributes(uri, languageId, schema);
+            if (GetAttributes(uri, out var languageId, out var scheme))
+            {
+                yield return new TextDocumentAttributes(uri, languageId, scheme);
+            }
         }
 
-        protected abstract (string languageId, string schema) GetAttributes(DocumentUri uri);
+        protected abstract bool GetAttributes(DocumentUri uri, out string languageId, out string scheme);
     }
 
+    public class WellKnownLanguageIdentifier : TextDocumentIdentifierBase
+    {
+        private readonly string _languageId;
+        private readonly Minimatcher[] _minimatchers;
+        public WellKnownLanguageIdentifier(
+            string name,
+            string languageId,
+            params string[] filePatterns)
+        {
+            Name = name;
+            _languageId = languageId;
+            _minimatchers = filePatterns.Select(z => new Minimatcher(z)).ToArray();
+        }
+
+        public string Name { get; }
+
+        protected override bool GetAttributes(DocumentUri uri, out string languageId, out string scheme)
+        {
+            languageId = _languageId;
+            scheme = uri.Scheme;
+            return _minimatchers.Any(z => z.IsMatch(uri.ToString()));
+        }
+    }
+
+    public static class WellKnownLanguages
+    {
+        public static readonly WellKnownLanguageIdentifier ABAP = new WellKnownLanguageIdentifier("ABAP", "abap", "**/*.abap");
+        public static readonly WellKnownLanguageIdentifier WindowsBatch  = new WellKnownLanguageIdentifier("Windows Bat", "bat", "**/*.{bat,cmd}");
+        public static readonly WellKnownLanguageIdentifier BibTeX  = new WellKnownLanguageIdentifier("BibTeX", "bibtex", "**/*.bib");
+        public static readonly WellKnownLanguageIdentifier Clojure  = new WellKnownLanguageIdentifier("Clojure", "clojure", "**/*.{clj,cljs,cljc,ed}");
+        public static readonly WellKnownLanguageIdentifier CoffeeScript  = new WellKnownLanguageIdentifier("Coffeescript", "coffeescript", "**/*.{coffee,litcoffee}");
+        public static readonly WellKnownLanguageIdentifier C  = new WellKnownLanguageIdentifier("C", "c", "**/*.{c,h}");
+        public static readonly WellKnownLanguageIdentifier CPlusPlus  = new WellKnownLanguageIdentifier("C++", "cpp", "**/*.{c,cc,cpp,cxx,c++,h,hh,hpp,hxx,h++}");
+        public static readonly WellKnownLanguageIdentifier CSharp  = new WellKnownLanguageIdentifier("C#", "csharp", "**/*.{cs,csi,csx,cake}");
+        public static readonly WellKnownLanguageIdentifier CSS  = new WellKnownLanguageIdentifier("CSS", "css", "**/*.css");
+        public static readonly WellKnownLanguageIdentifier Diff  = new WellKnownLanguageIdentifier("Diff", "diff", "**/*.diff");
+        public static readonly WellKnownLanguageIdentifier Dart  = new WellKnownLanguageIdentifier("Dart", "dart", "**/*.dart");
+        public static readonly WellKnownLanguageIdentifier Dockerfile  = new WellKnownLanguageIdentifier("Dockerfile", "dockerfile", "**/*.dockerfile");
+        public static readonly WellKnownLanguageIdentifier Elixir  = new WellKnownLanguageIdentifier("Elixir", "elixir", "**/*.{ex,exs}");
+        public static readonly WellKnownLanguageIdentifier Erlang  = new WellKnownLanguageIdentifier("Erlang", "erlang", "**/*.{erl,hrl}");
+        public static readonly WellKnownLanguageIdentifier FSharp  = new WellKnownLanguageIdentifier("F#", "fsharp", "**/*.{fs,fsi,fsx,fsscript}");
+        public static readonly WellKnownLanguageIdentifier Go  = new WellKnownLanguageIdentifier("Go", "go", "**/*.go");
+        public static readonly WellKnownLanguageIdentifier Groovy  = new WellKnownLanguageIdentifier("Groovy", "groovy", "**/*.{groovy,gvy,gy,gsh}");
+        public static readonly WellKnownLanguageIdentifier Handlebars  = new WellKnownLanguageIdentifier("Handlebars", "handlebars", "**/*.{handlebars,hbs,mustache}");
+        public static readonly WellKnownLanguageIdentifier HTML  = new WellKnownLanguageIdentifier("HTML", "html", "**/*.{html,htm}");
+        public static readonly WellKnownLanguageIdentifier Ini  = new WellKnownLanguageIdentifier("Ini", "ini", "**/*.ini");
+        public static readonly WellKnownLanguageIdentifier Java  = new WellKnownLanguageIdentifier("Java", "java", "**/*.{java,class}");
+        public static readonly WellKnownLanguageIdentifier JavaScript  = new WellKnownLanguageIdentifier("JavaScript", "javascript", "**/*.{js,mjs}");
+        public static readonly WellKnownLanguageIdentifier JavaScriptReact  = new WellKnownLanguageIdentifier("JavaScript React", "javascriptreact", "**/*.jsx");
+        public static readonly WellKnownLanguageIdentifier JSON  = new WellKnownLanguageIdentifier("JSON", "json", "**/*.json");
+        public static readonly WellKnownLanguageIdentifier LaTeX  = new WellKnownLanguageIdentifier("TeX", "latex", "**/*.tex");
+        public static readonly WellKnownLanguageIdentifier Less  = new WellKnownLanguageIdentifier("Less", "less", "**/*.less");
+        public static readonly WellKnownLanguageIdentifier Lua  = new WellKnownLanguageIdentifier("Lua", "lua", "**/*.lua");
+        public static readonly WellKnownLanguageIdentifier Markdown  = new WellKnownLanguageIdentifier("Markdown", "markdown", "**/*.{markdown,mdown,mkdn,mkd,md}");
+        public static readonly WellKnownLanguageIdentifier ObjectiveC  = new WellKnownLanguageIdentifier("Objective-C", "objective-c", "**/*.{h,m,mm,M}");
+        public static readonly WellKnownLanguageIdentifier ObjectiveCPlusPlus  = new WellKnownLanguageIdentifier("Objective-C++", "objective-cpp", "**/*.{h,mm}");
+        public static readonly WellKnownLanguageIdentifier Perl  = new WellKnownLanguageIdentifier("Perl", "perl", "**/*.{plx,pl,pm,xs,t,pod}");
+        public static readonly WellKnownLanguageIdentifier Raku  = new WellKnownLanguageIdentifier("Raku", "raku", "**/*.{p6,pm6,pod6,t6,raku,rakumod,rakudoc,rakutest}");
+        public static readonly WellKnownLanguageIdentifier PHP  = new WellKnownLanguageIdentifier("PHP", "php", "**/*.{php,phtml,php3,php4,php5,php7,phps,php-s,pht,pha}");
+        public static readonly WellKnownLanguageIdentifier PowerShell  = new WellKnownLanguageIdentifier("PowerShell", "powershell", "**/*.{ps1,psd1,psm1}");
+        public static readonly WellKnownLanguageIdentifier Pug  = new WellKnownLanguageIdentifier("Pug", "jade", "**/*.{pug}");
+        public static readonly WellKnownLanguageIdentifier Python  = new WellKnownLanguageIdentifier("Python", "python", "**/*.{py,pyi,pyc,pyd,pyo,pyw,pyz}");
+        public static readonly WellKnownLanguageIdentifier R  = new WellKnownLanguageIdentifier("R", "r", "**/*.{r,rdata,rds,rda}");
+        public static readonly WellKnownLanguageIdentifier Razor  = new WellKnownLanguageIdentifier("Razor", "razor", "**/*.{razor,cshtml}");
+        public static readonly WellKnownLanguageIdentifier Ruby  = new WellKnownLanguageIdentifier("Ruby", "ruby", "**/*.rb");
+        public static readonly WellKnownLanguageIdentifier Rust  = new WellKnownLanguageIdentifier("Rust", "rust", "**/*.{rs,rlib}");
+        public static readonly WellKnownLanguageIdentifier SCSS  = new WellKnownLanguageIdentifier("SCSS", "scss", "**/*.{scss,sass}");
+        public static readonly WellKnownLanguageIdentifier Scala  = new WellKnownLanguageIdentifier("Scala", "scala", "**/*.{scala,sc}");
+        public static readonly WellKnownLanguageIdentifier SQL  = new WellKnownLanguageIdentifier("SQL", "sql", "**/*.sql");
+        public static readonly WellKnownLanguageIdentifier Swift  = new WellKnownLanguageIdentifier("Swift", "swift", "**/*.swift");
+        public static readonly WellKnownLanguageIdentifier TypeScript  = new WellKnownLanguageIdentifier("TypeScript", "typescript", "**/*.ts");
+        public static readonly WellKnownLanguageIdentifier TypeScriptReact  = new WellKnownLanguageIdentifier("TypeScript React", "typescriptreact", "**/*.tsx");
+        public static readonly WellKnownLanguageIdentifier TeX  = new WellKnownLanguageIdentifier("TeX", "tex", "**/*.tex");
+        public static readonly WellKnownLanguageIdentifier VisualBasic  = new WellKnownLanguageIdentifier("Visual Basic", "vb", "**/*.vb");
+        public static readonly WellKnownLanguageIdentifier XML  = new WellKnownLanguageIdentifier("XML", "xml", "**/*.xml");
+        public static readonly WellKnownLanguageIdentifier XSL  = new WellKnownLanguageIdentifier("XSL", "xsl", "**/*.xsl");
+        public static readonly WellKnownLanguageIdentifier YAML  = new WellKnownLanguageIdentifier("YAML", "yaml", "**/*.{yaml,yml}");
+    }
+
+
+
+
     public class TextDocumentIdentifiers : IEnumerable<ITextDocumentIdentifier>
     {
         private readonly HashSet<ITextDocumentIdentifier> _textDocumentIdentifiers = new HashSet<ITextDocumentIdentifier>();
diff --git a/src/Protocol/Document/ITextDocumentSyncHandler.cs b/src/Protocol/Document/ITextDocumentSyncHandler.cs
index bed599868..0c8d1559d 100644
--- a/src/Protocol/Document/ITextDocumentSyncHandler.cs
+++ b/src/Protocol/Document/ITextDocumentSyncHandler.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using MediatR;
@@ -38,7 +39,7 @@ TextDocumentSaveRegistrationOptions IRegistration<TextDocumentSaveRegistrationOp
         TextDocumentChangeRegistrationOptions IRegistration<TextDocumentChangeRegistrationOptions>.
             GetRegistrationOptions() => _changeOptions;
 
-        public abstract TextDocumentAttributes GetTextDocumentAttributes(DocumentUri uri);
+        public abstract IEnumerable<TextDocumentAttributes> GetTextDocumentAttributes(DocumentUri uri);
         public abstract Task<Unit> Handle(DidOpenTextDocumentParams request, CancellationToken cancellationToken);
         public abstract Task<Unit> Handle(DidChangeTextDocumentParams request, CancellationToken cancellationToken);
         public abstract Task<Unit> Handle(DidSaveTextDocumentParams request, CancellationToken cancellationToken);
@@ -49,7 +50,7 @@ TextDocumentChangeRegistrationOptions IRegistration<TextDocumentChangeRegistrati
 
     public static class TextDocumentSyncExtensions
     {
-public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
+        public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
             TextDocumentSyncKind kind,
             Func<DocumentUri, TextDocumentAttributes> getTextDocumentAttributes,
             Func<DidOpenTextDocumentParams, SynchronizationCapability, CancellationToken, Task> onOpenHandler,
@@ -63,7 +64,7 @@ public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerReg
                 onSaveHandler, getTextDocumentAttributes, registrationOptions, kind));
         }
 
-public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
+        public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
             TextDocumentSyncKind kind,
             Func<DocumentUri, TextDocumentAttributes> getTextDocumentAttributes,
             Action<DidOpenTextDocumentParams, SynchronizationCapability, CancellationToken> onOpenHandler,
@@ -77,7 +78,7 @@ public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerReg
                 onSaveHandler, getTextDocumentAttributes, registrationOptions, kind));
         }
 
-public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
+        public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
             TextDocumentSyncKind kind,
             Func<DocumentUri, TextDocumentAttributes> getTextDocumentAttributes,
             Action<DidOpenTextDocumentParams, SynchronizationCapability> onOpenHandler,
@@ -95,7 +96,7 @@ public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerReg
                 getTextDocumentAttributes, registrationOptions, kind));
         }
 
-public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
+        public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
             TextDocumentSyncKind kind,
             Func<DocumentUri, TextDocumentAttributes> getTextDocumentAttributes,
             Func<DidOpenTextDocumentParams, CancellationToken, Task> onOpenHandler,
@@ -113,7 +114,7 @@ public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerReg
                 getTextDocumentAttributes, registrationOptions, kind));
         }
 
-public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
+        public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
             TextDocumentSyncKind kind,
             Func<DocumentUri, TextDocumentAttributes> getTextDocumentAttributes,
             Action<DidOpenTextDocumentParams, CancellationToken> onOpenHandler,
@@ -131,7 +132,7 @@ public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerReg
                 getTextDocumentAttributes, registrationOptions, kind));
         }
 
-public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
+        public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
             TextDocumentSyncKind kind,
             Func<DocumentUri, TextDocumentAttributes> getTextDocumentAttributes,
             Func<DidOpenTextDocumentParams, Task> onOpenHandler,
@@ -149,7 +150,7 @@ public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerReg
                 getTextDocumentAttributes, registrationOptions, kind));
         }
 
-public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
+        public static ILanguageServerRegistry OnTextDocumentSync(this ILanguageServerRegistry registry,
             TextDocumentSyncKind kind,
             Func<DocumentUri, TextDocumentAttributes> getTextDocumentAttributes,
             Action<DidOpenTextDocumentParams> onOpenHandler,
@@ -258,8 +259,10 @@ public override async Task<Unit> Handle(DidCloseTextDocumentParams request,
                 return Unit.Value;
             }
 
-            public override TextDocumentAttributes GetTextDocumentAttributes(DocumentUri uri) =>
-                _getTextDocumentAttributes.Invoke(uri);
+            public override IEnumerable<TextDocumentAttributes> GetTextDocumentAttributes(DocumentUri uri)
+            {
+                yield return _getTextDocumentAttributes.Invoke(uri);
+            }
 
             public override void SetCapability(SynchronizationCapability capability)
             {
diff --git a/src/Protocol/Models/CodeLens.cs b/src/Protocol/Models/CodeLens.cs
index 8308189fd..593e4ad9e 100644
--- a/src/Protocol/Models/CodeLens.cs
+++ b/src/Protocol/Models/CodeLens.cs
@@ -5,6 +5,34 @@
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
+    /// <summary>
+    /// A code lens represents a command that should be shown along with
+    /// source text, like the number of references, a way to run tests, etc.
+    ///
+    /// A code lens is _unresolved_ when no command is associated to it. For performance
+    /// reasons the creation of a code lens and resolving should be done in two stages.
+    /// </summary>
+    public interface ICodeLens<out TData> : ICanBeResolved<TData> where TData : CanBeResolvedData
+    {
+        /// <summary>
+        /// The range in which this code lens is valid. Should only span a single line.
+        /// </summary>
+        Range Range { get; }
+
+        /// <summary>
+        /// The command this code lens represents.
+        /// </summary>
+        [Optional]
+        Command Command { get; }
+
+        /// <summary>
+        /// A data entry field that is preserved on a code lens item between
+        /// a code lens and a code lens resolve request.
+        /// </summary>
+        [Optional]
+        TData Data { get; }
+    }
+
     /// <summary>
     /// A code lens represents a command that should be shown along with
     /// source text, like the number of references, a way to run tests, etc.
@@ -13,8 +41,23 @@ namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
     /// reasons the creation of a code lens and resolving should be done in two stages.
     /// </summary>
     [Method(TextDocumentNames.CodeLensResolve, Direction.ClientToServer)]
-    public class CodeLens : ICanBeResolved, IRequest<CodeLens>
+    public class CodeLens<TData> : ICodeLens<TData>, IRequest<CodeLens<TData>>
+        where TData : CanBeResolvedData
     {
+        /// <summary>
+        /// Used for aggregating results when completion is supported by multiple handlers
+        /// </summary>
+        public static CodeLens<TData> From(ICodeLens<TData> item)
+        {
+            return item is CodeLens<TData> cl
+                ? cl
+                : new CodeLens<TData>() {
+                    Command = item.Command,
+                    Data = item.Data,
+                    Range = item.Range
+                };
+        }
+
         /// <summary>
         /// The range in which this code lens is valid. Should only span a single line.
         /// </summary>
@@ -31,6 +74,6 @@ public class CodeLens : ICanBeResolved, IRequest<CodeLens>
         /// a code lens and a code lens resolve request.
         /// </summary>
         [Optional]
-        public JToken Data { get; set; }
+        public TData Data { get; set; }
     }
 }
diff --git a/src/Protocol/Models/CodeLensContainer.cs b/src/Protocol/Models/CodeLensContainer.cs
index 8f31f89b5..fe29c5883 100644
--- a/src/Protocol/Models/CodeLensContainer.cs
+++ b/src/Protocol/Models/CodeLensContainer.cs
@@ -1,36 +1,48 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using OmniSharp.Extensions.JsonRpc;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
-    public class CodeLensContainer : Container<CodeLens>
+    public class CodeLensContainer<TData> : Container<CodeLens<TData>>, IAggregateResults
+        where TData : CanBeResolvedData
     {
-        public CodeLensContainer() : this(Enumerable.Empty<CodeLens>())
+        public CodeLensContainer() : this(Enumerable.Empty<CodeLens<TData>>())
         {
         }
 
-        public CodeLensContainer(IEnumerable<CodeLens> items) : base(items)
+        public CodeLensContainer(IEnumerable<CodeLens<TData>> items) : base(items)
         {
         }
 
-        public CodeLensContainer(params CodeLens[] items) : base(items)
+        public CodeLensContainer(params CodeLens<TData>[] items) : base(items)
         {
         }
 
-        public static implicit operator CodeLensContainer(CodeLens[] items)
+        public static implicit operator CodeLensContainer<TData>(CodeLens<TData>[] items)
         {
-            return new CodeLensContainer(items);
+            return new CodeLensContainer<TData>(items);
         }
 
-        public static implicit operator CodeLensContainer(Collection<CodeLens> items)
+        public static implicit operator CodeLensContainer<TData>(Collection<CodeLens<TData>> items)
         {
-            return new CodeLensContainer(items);
+            return new CodeLensContainer<TData>(items);
         }
 
-        public static implicit operator CodeLensContainer(List<CodeLens> items)
+        public static implicit operator CodeLensContainer<TData>(List<CodeLens<TData>> items)
         {
-            return new CodeLensContainer(items);
+            return new CodeLensContainer<TData>(items);
+        }
+
+        object IAggregateResults.AggregateResults(IEnumerable<object> values)
+        {
+            return new CodeLensContainer<CanBeResolvedData>(
+                values.Cast<IEnumerable<object>>()
+                    .SelectMany(z => z.OfType<ICodeLens<CanBeResolvedData>>())
+                    .Concat(this)
+                    .Select(CodeLens<CanBeResolvedData>.From)
+            );
         }
     }
 }
diff --git a/src/Protocol/Models/CodeLensParams.cs b/src/Protocol/Models/CodeLensParams.cs
index 45e560b0a..0e45c08a7 100644
--- a/src/Protocol/Models/CodeLensParams.cs
+++ b/src/Protocol/Models/CodeLensParams.cs
@@ -1,10 +1,11 @@
+using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.JsonRpc;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
     [Method(TextDocumentNames.CodeLens, Direction.ClientToServer)]
-    public class CodeLensParams : ITextDocumentIdentifierParams, IWorkDoneProgressParams, IPartialItemsRequest<CodeLensContainer, CodeLens>
+    public class CodeLensParams<TData> : ITextDocumentIdentifierParams, IWorkDoneProgressParams, IPartialItemsRequest<CodeLensContainer<TData>, CodeLens<TData>> where TData : CanBeResolvedData
     {
         /// <summary>
         /// The document to request code lens for.
diff --git a/src/Protocol/Models/CompletionItem.cs b/src/Protocol/Models/CompletionItem.cs
index 5f2bcaa0c..8c4edda71 100644
--- a/src/Protocol/Models/CompletionItem.cs
+++ b/src/Protocol/Models/CompletionItem.cs
@@ -5,9 +5,162 @@
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
+    public interface ICompletionItem<out TData> : ICanBeResolved<TData>
+        where TData : CanBeResolvedData
+    {
+        /// <summary>
+        /// The label of this completion item. By default
+        /// also the text that is inserted when selecting
+        /// this completion.
+        /// </summary>
+        public string Label { get; }
+
+        /// <summary>
+        /// The kind of this completion item. Based of the kind
+        /// an icon is chosen by the editor.
+        /// </summary>
+        [Optional]
+        public CompletionItemKind Kind { get; }
+
+        /// <summary>
+        /// Tags for this completion item.
+        ///
+        /// @since 3.15.0
+        /// </summary>
+        public Container<CompletionItemTag> Tags { get; }
+
+        /// <summary>
+        /// A human-readable string with additional information
+        /// about this item, like type or symbol information.
+        /// </summary>
+        [Optional]
+        public string Detail { get; }
+
+        /// <summary>
+        /// A human-readable string that represents a doc-comment.
+        /// </summary>
+        [Optional]
+        public StringOrMarkupContent Documentation { get; }
+
+        /// <summary>
+        /// Indicates if this item is deprecated.
+        /// </summary>
+        [Optional]
+        public bool Deprecated { get; }
+
+        /// <summary>
+        /// Select this item when showing.
+        ///
+        /// *Note* that only one completion item can be selected and that the
+        /// tool / client decides which item that is. The rule is that the *first*
+        /// item of those that match best is selected.
+        /// </summary>
+        [Optional]
+        public bool Preselect { get; }
+
+        /// <summary>
+        /// A string that shoud be used when comparing this item
+        /// with other items. When `falsy` the label is used.
+        /// </summary>
+        [Optional]
+        public string SortText { get; }
+
+        /// <summary>
+        /// A string that should be used when filtering a set of
+        /// completion items. When `falsy` the label is used.
+        /// </summary>
+
+        [Optional]
+        public string FilterText { get; }
+
+        /// <summary>
+        /// A string that should be inserted a document when selecting
+        /// this completion. When `falsy` the label is used.
+        /// </summary>
+
+        [Optional]
+        public string InsertText { get; }
+
+        /// <summary>
+        /// The format of the insert text. The format applies to both the `insertText` property
+        /// and the `newText` property of a provided `textEdit`.
+        /// </summary>
+        [Optional]
+        public InsertTextFormat InsertTextFormat { get; }
+
+        /// <summary>
+        /// An edit which is applied to a document when selecting this completion. When an edit is provided the value of
+        /// `insertText` is ignored.
+        ///
+        /// *Note:* The range of the edit must be a single line range and it must contain the position at which completion
+        /// has been requested.
+        /// </summary>
+        [Optional]
+        public TextEdit TextEdit { get; }
+
+        /// <summary>
+        /// An optional array of additional text edits that are applied when
+        /// selecting this completion. Edits must not overlap with the main edit
+        /// nor with themselves.
+        /// </summary>
+        [Optional]
+        public TextEditContainer AdditionalTextEdits { get; }
+
+        /// <summary>
+        /// An optional set of characters that when pressed while this completion is active will accept it first and
+        /// then type that character. *Note* that all commit characters should have `length=1` and that superfluous
+        /// characters will be ignored.
+        /// </summary>
+        [Optional]
+        public Container<string> CommitCharacters { get; }
+
+        /// <summary>
+        /// An optional command that is executed/// after* inserting this completion./// Note* that
+        /// additional modifications to the current document should be described with the
+        /// additionalTextEdits-property.
+        /// </summary>
+        [Optional]
+        public Command Command { get; }
+
+        /// <summary>
+        /// An data entry field that is preserved on a completion item between
+        /// a completion and a completion resolve request.
+        /// </summary>
+        [Optional]
+        public TData Data { get; }
+    }
+
     [Method(TextDocumentNames.CompletionResolve, Direction.ClientToServer)]
-    public class CompletionItem : ICanBeResolved, IRequest<CompletionItem>
+    public class CompletionItem<TData> : ICompletionItem<TData>, IRequest<CompletionItem<TData>>
+        where TData : CanBeResolvedData
     {
+        /// <summary>
+        /// Used for aggregating results when completion is supported by multiple handlers
+        /// </summary>
+        public static CompletionItem<TData> From(ICompletionItem<TData> item)
+        {
+            return item is CompletionItem<TData> cl
+                ? cl
+                : new CompletionItem<TData>() {
+                    Command = item.Command,
+                    Data = item.Data,
+                    Deprecated = item.Deprecated,
+                    Detail = item.Detail,
+                    Documentation = item.Documentation,
+                    Kind = item.Kind,
+                    Label = item.Label,
+                    Preselect = item.Preselect,
+                    Tags = item.Tags,
+                    CommitCharacters = item.CommitCharacters,
+                    FilterText = item.FilterText,
+                    InsertText = item.InsertText,
+                    SortText = item.SortText,
+                    TextEdit = item.TextEdit,
+                    AdditionalTextEdits = item.AdditionalTextEdits,
+                    InsertTextFormat = item.InsertTextFormat
+                };
+        }
+
         /// <summary>
         /// The label of this completion item. By default
         /// also the text that is inserted when selecting
@@ -127,6 +280,6 @@ public class CompletionItem : ICanBeResolved, IRequest<CompletionItem>
         /// a completion and a completion resolve request.
         /// </summary>
         [Optional]
-        public JToken Data { get; set; }
+        public TData Data { get; set; }
     }
 }
diff --git a/src/Protocol/Models/CompletionList.cs b/src/Protocol/Models/CompletionList.cs
index 29817dc51..23403bb3f 100644
--- a/src/Protocol/Models/CompletionList.cs
+++ b/src/Protocol/Models/CompletionList.cs
@@ -1,29 +1,55 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using Newtonsoft.Json.Linq;
+using OmniSharp.Extensions.JsonRpc;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
+    interface ICompletionList
+    {
+        /// <summary>
+        /// This list it not complete. Further typing should result in recomputing
+        /// this list.
+        /// </summary>
+        public bool IsIncomplete { get; }
+
+        /// <summary>
+        /// The completion items.
+        /// </summary>
+        public IEnumerable<object> Items { get; }
+    }
+
     /// <summary>
     /// Represents a collection of [completion items](#CompletionItem) to be presented
     /// in the editor.
     /// </summary>
-    public class CompletionList : Container<CompletionItem>
+    public class CompletionList<TData> : Container<CompletionItem<TData>>, ICompletionList, IAggregateResults
+        where TData : CanBeResolvedData
     {
-        public CompletionList() : base(Enumerable.Empty<CompletionItem>()) { }
-        public CompletionList(bool isIncomplete) : base(Enumerable.Empty<CompletionItem>())
+        public CompletionList() : base(Enumerable.Empty<CompletionItem<TData>>())
+        {
+        }
+
+        public CompletionList(bool isIncomplete) : base(Enumerable.Empty<CompletionItem<TData>>())
         {
             IsIncomplete = isIncomplete;
         }
 
-        public CompletionList(IEnumerable<CompletionItem> items) : base(items) { }
-        public CompletionList(IEnumerable<CompletionItem> items, bool isIncomplete) : base(items)
+        public CompletionList(IEnumerable<CompletionItem<TData>> items) : base(items)
+        {
+        }
+
+        public CompletionList(IEnumerable<CompletionItem<TData>> items, bool isIncomplete) : base(items)
         {
             IsIncomplete = isIncomplete;
         }
 
-        public CompletionList(params CompletionItem[] items) : base(items) { }
-        public CompletionList(bool isIncomplete, params CompletionItem[] items) : base(items)
+        public CompletionList(params CompletionItem<TData>[] items) : base(items)
+        {
+        }
+
+        public CompletionList(bool isIncomplete, params CompletionItem<TData>[] items) : base(items)
         {
             IsIncomplete = isIncomplete;
         }
@@ -37,24 +63,88 @@ public CompletionList(bool isIncomplete, params CompletionItem[] items) : base(i
         /// <summary>
         /// The completion items.
         /// </summary>
-        public IEnumerable<CompletionItem> Items => this;
+        public IEnumerable<CompletionItem<TData>> Items => this;
+
+        IEnumerable<object> ICompletionList.Items => this;
+
+        public static implicit operator CompletionList<TData>(CompletionItem<TData>[] items)
+        {
+            return new CompletionList<TData>(items);
+        }
+
+        public static implicit operator CompletionList<TData>(Collection<CompletionItem<TData>> items)
+        {
+            return new CompletionList<TData>(items);
+        }
+
+        public static implicit operator CompletionList<TData>(List<CompletionItem<TData>> items)
+        {
+            return new CompletionList<TData>(items);
+        }
+
+        public static implicit operator CompletionItem<TData>[](CompletionList<TData> list)
+        {
+            return list.ToArray();
+        }
+
+        object IAggregateResults.AggregateResults(IEnumerable<object> values)
+        {
+            return new CompletionList<CanBeResolvedData>(
+                values
+                    .Cast<IEnumerable<object>>()
+                    .SelectMany(z => z.OfType<ICompletionItem<CanBeResolvedData>>())
+                    .Concat(this)
+                    .Select(CompletionItem<CanBeResolvedData>.From)
+            );
+        }
+    }
+
+    /// <summary>
+    /// Represents a collection of [completion items](#CompletionItem) to be presented
+    /// in the editor.
+    /// </summary>
+    public class CompletionList : CompletionList<ResolvedData>
+    {
+        public CompletionList() : base(Enumerable.Empty<CompletionItem<ResolvedData>>())
+        {
+        }
+
+        public CompletionList(bool isIncomplete) : base(isIncomplete)
+        {
+        }
+
+        public CompletionList(IEnumerable<CompletionItem<ResolvedData>> items) : base(items)
+        {
+        }
+
+        public CompletionList(IEnumerable<CompletionItem<ResolvedData>> items, bool isIncomplete) : base(items, isIncomplete)
+        {
+        }
+
+        public CompletionList(params CompletionItem<ResolvedData>[] items) : base(items)
+        {
+        }
+
+        public CompletionList(bool isIncomplete, params CompletionItem<ResolvedData>[] items) : base(isIncomplete, items)
+        {
+        }
 
-        public static implicit operator CompletionList(CompletionItem[] items)
+        public static implicit operator CompletionList(CompletionItem<ResolvedData>[] items)
         {
             return new CompletionList(items);
         }
 
-        public static implicit operator CompletionList(Collection<CompletionItem> items)
+        public static implicit operator CompletionList(Collection<CompletionItem<ResolvedData>> items)
         {
             return new CompletionList(items);
         }
 
-        public static implicit operator CompletionList(List<CompletionItem> items)
+        public static implicit operator CompletionList(List<CompletionItem<ResolvedData>> items)
         {
             return new CompletionList(items);
         }
 
-        public static implicit operator CompletionItem[] (CompletionList list)
+        public static implicit operator CompletionItem<ResolvedData>[](CompletionList list)
         {
             return list.ToArray();
         }
diff --git a/src/Protocol/Models/CompletionParams.cs b/src/Protocol/Models/CompletionParams.cs
index 38c368da9..3f907febf 100644
--- a/src/Protocol/Models/CompletionParams.cs
+++ b/src/Protocol/Models/CompletionParams.cs
@@ -1,10 +1,11 @@
+using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.JsonRpc;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
     [Method(TextDocumentNames.Completion, Direction.ClientToServer)]
-    public class CompletionParams : WorkDoneTextDocumentPositionParams, IPartialItemsRequest<CompletionList, CompletionItem>
+    public class CompletionParams<TData> : WorkDoneTextDocumentPositionParams, IPartialItemsRequest<CompletionList<TData>, CompletionItem<TData>> where TData : CanBeResolvedData
     {
         /// <summary>
         /// The completion context. This is only available it the client specifies to send
diff --git a/src/Protocol/Models/DocumentLink.cs b/src/Protocol/Models/DocumentLink.cs
index cbc2c1d5f..7e90ddff3 100644
--- a/src/Protocol/Models/DocumentLink.cs
+++ b/src/Protocol/Models/DocumentLink.cs
@@ -5,13 +5,65 @@
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
+    /// <summary>
+    /// A document link is a range in a text document that links to an internal or external resource, like another
+    /// text document or a web site.
+    /// </summary>
+    public interface IDocumentLink<out TData> : ICanBeResolved<TData> where TData : CanBeResolvedData
+    {
+        /// <summary>
+        /// The range this link applies to.
+        /// </summary>
+        public Range Range { get; }
+
+        /// <summary>
+        /// The uri this link points to. If missing a resolve request is sent later.
+        /// </summary>
+        [Optional]
+        public DocumentUri Target { get; }
+
+        /// </summary>
+        /// A data entry field that is preserved on a document link between a
+        /// DocumentLinkRequest and a DocumentLinkResolveRequest.
+        /// </summary>
+        [Optional]
+        public TData Data { get; }
+
+        /// <summary>
+        /// The tooltip text when you hover over this link.
+        ///
+        /// If a tooltip is provided, is will be displayed in a string that includes instructions on how to
+        /// trigger the link, such as `{0} (ctrl + click)`. The specific instructions vary depending on OS,
+        /// user settings, and localization.
+        ///
+        /// @since 3.15.0
+        /// </summary>
+        [Optional]
+        public string Tooltip { get; }
+    }
+
     /// <summary>
     /// A document link is a range in a text document that links to an internal or external resource, like another
     /// text document or a web site.
     /// </summary>
     [Method(TextDocumentNames.DocumentLinkResolve, Direction.ClientToServer)]
-    public class DocumentLink : ICanBeResolved, IRequest<DocumentLink>
+    public class DocumentLink<TData> : IDocumentLink<TData>, IRequest<DocumentLink<TData>> where TData : CanBeResolvedData
     {
+        /// <summary>
+        /// Used for aggregating results when completion is supported by multiple handlers
+        /// </summary>
+        public static DocumentLink<TData> From(IDocumentLink<TData> item)
+        {
+            return item is DocumentLink<TData> cl
+                ? cl
+                : new DocumentLink<TData>() {
+                    Data = item.Data,
+                    Range = item.Range,
+                    Target = item.Target,
+                    Tooltip = item.Tooltip
+                };
+        }
+
         /// <summary>
         /// The range this link applies to.
         /// </summary>
@@ -28,7 +80,7 @@ public class DocumentLink : ICanBeResolved, IRequest<DocumentLink>
         /// DocumentLinkRequest and a DocumentLinkResolveRequest.
         /// </summary>
         [Optional]
-        public JToken Data { get; set; }
+        public TData Data { get; set; }
 
         /// <summary>
         /// The tooltip text when you hover over this link.
diff --git a/src/Protocol/Models/DocumentLinkContainer.cs b/src/Protocol/Models/DocumentLinkContainer.cs
index e8b2f6caf..7d24fdd9b 100644
--- a/src/Protocol/Models/DocumentLinkContainer.cs
+++ b/src/Protocol/Models/DocumentLinkContainer.cs
@@ -1,36 +1,49 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using OmniSharp.Extensions.JsonRpc;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
-    public class DocumentLinkContainer : Container<DocumentLink>
+    public class DocumentLinkContainer<TData> : Container<DocumentLink<TData>>, IAggregateResults
+        where TData : CanBeResolvedData
     {
-        public DocumentLinkContainer() : this(Enumerable.Empty<DocumentLink>())
+        public DocumentLinkContainer() : this(Enumerable.Empty<DocumentLink<TData>>())
         {
         }
 
-        public DocumentLinkContainer(IEnumerable<DocumentLink> items) : base(items)
+        public DocumentLinkContainer(IEnumerable<DocumentLink<TData>> items) : base(items)
         {
         }
 
-        public DocumentLinkContainer(params DocumentLink[] items) : base(items)
+        public DocumentLinkContainer(params DocumentLink<TData>[] items) : base(items)
         {
         }
 
-        public static implicit operator DocumentLinkContainer(DocumentLink[] items)
+        public static implicit operator DocumentLinkContainer<TData>(DocumentLink<TData>[] items)
         {
-            return new DocumentLinkContainer(items);
+            return new DocumentLinkContainer<TData>(items);
         }
 
-        public static implicit operator DocumentLinkContainer(Collection<DocumentLink> items)
+        public static implicit operator DocumentLinkContainer<TData>(Collection<DocumentLink<TData>> items)
         {
-            return new DocumentLinkContainer(items);
+            return new DocumentLinkContainer<TData>(items);
         }
 
-        public static implicit operator DocumentLinkContainer(List<DocumentLink> items)
+        public static implicit operator DocumentLinkContainer<TData>(List<DocumentLink<TData>> items)
         {
-            return new DocumentLinkContainer(items);
+            return new DocumentLinkContainer<TData>(items);
+        }
+
+        object IAggregateResults.AggregateResults(IEnumerable<object> values)
+        {
+            return new DocumentLinkContainer<CanBeResolvedData>(
+                values
+                    .Cast<IEnumerable<object>>()
+                    .SelectMany(z => z.OfType<IDocumentLink<CanBeResolvedData>>())
+                    .Concat(this)
+                    .Select(DocumentLink<CanBeResolvedData>.From)
+            );
         }
     }
 }
diff --git a/src/Protocol/Models/DocumentLinkParams.cs b/src/Protocol/Models/DocumentLinkParams.cs
index 92d77c2a0..86518bd0e 100644
--- a/src/Protocol/Models/DocumentLinkParams.cs
+++ b/src/Protocol/Models/DocumentLinkParams.cs
@@ -1,10 +1,11 @@
+using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.JsonRpc;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
     [Method(TextDocumentNames.DocumentLink, Direction.ClientToServer)]
-    public class DocumentLinkParams : ITextDocumentIdentifierParams, IPartialItemsRequest<DocumentLinkContainer, DocumentLink>, IWorkDoneProgressParams
+    public class DocumentLinkParams<TData> : ITextDocumentIdentifierParams, IPartialItemsRequest<DocumentLinkContainer<TData>, DocumentLink<TData>>, IWorkDoneProgressParams where TData : CanBeResolvedData
     {
         /// <summary>
         /// The document to provide document links for.
diff --git a/src/Protocol/Models/ICanBeIdentifiedHandler.cs b/src/Protocol/Models/ICanBeIdentifiedHandler.cs
new file mode 100644
index 000000000..33cf56a40
--- /dev/null
+++ b/src/Protocol/Models/ICanBeIdentifiedHandler.cs
@@ -0,0 +1,22 @@
+using System;
+using MediatR;
+using OmniSharp.Extensions.JsonRpc;
+
+namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
+{
+    /// <summary>
+    /// Common interface for types that support resolution.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface ICanBeResolvedHandler<T, TData> : IJsonRpcRequestHandler<T, T>, ICanBeIdentifiedHandler
+        where T : ICanBeResolved<TData>, IRequest<T>
+        where TData : CanBeResolvedData
+    {
+
+    }
+
+    public interface ICanBeIdentifiedHandler
+    {
+        Guid Id { get; }
+    }
+}
diff --git a/src/Protocol/Models/ICanBeResolved.cs b/src/Protocol/Models/ICanBeResolved.cs
index 27c2e864e..2375a34ed 100644
--- a/src/Protocol/Models/ICanBeResolved.cs
+++ b/src/Protocol/Models/ICanBeResolved.cs
@@ -1,3 +1,6 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
 
@@ -6,12 +9,31 @@ namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
     /// <summary>
     /// Common interface for types that support resolution.
     /// </summary>
-    public interface ICanBeResolved
+    public interface ICanBeResolved<out T>
+        where T : CanBeResolvedData
     {
         /// <summary>
-        /// A data entry field that is preserved for resolve requests
+        /// A data entry field that is preserved for resolve requests~
         /// </summary>
         [Optional]
-        JToken Data { get; set; }
+        T Data { get; }
+    }
+
+    public class CanBeResolvedData
+    {
+        [Newtonsoft.Json.JsonProperty(PropertyName = "$$___handler___$$", NullValueHandling = NullValueHandling.Ignore)]
+        internal Guid? handler;
+        [JsonExtensionData]
+        internal IDictionary<string, JToken> data { get; set; } = new Dictionary<string, JToken>();
+    }
+
+    public sealed class ResolvedData : CanBeResolvedData
+    {
+        [JsonIgnore]
+        public IDictionary<string, JToken> Data
+        {
+            get => data;
+            set => data = value;
+        }
     }
 }
diff --git a/src/Protocol/Models/ICanBeResolvedHandler.cs b/src/Protocol/Models/ICanBeResolvedHandler.cs
deleted file mode 100644
index d4085b0ed..000000000
--- a/src/Protocol/Models/ICanBeResolvedHandler.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using MediatR;
-using OmniSharp.Extensions.JsonRpc;
-
-namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
-{
-    /// <summary>
-    /// Common interface for types that support resolution.
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    public interface ICanBeResolvedHandler<T> : IJsonRpcRequestHandler<T, T>
-        where T : ICanBeResolved, IRequest<T>
-    {
-        /// <summary>
-        /// Method that determines if a handler can be used to resolve this one
-        /// </summary>
-        /// <param name="value"></param>
-        /// <returns></returns>
-        bool CanResolve(T value);
-    }
-}
diff --git a/src/Protocol/Serialization/ContractResolver.cs b/src/Protocol/Serialization/ContractResolver.cs
index dad2f64ad..21dc973fe 100644
--- a/src/Protocol/Serialization/ContractResolver.cs
+++ b/src/Protocol/Serialization/ContractResolver.cs
@@ -80,7 +80,7 @@ protected override JsonProperty CreateProperty(MemberInfo member, MemberSerializ
                 property.ValueProvider = new SupportsValueProvider(property.ValueProvider);
             }
 
-            if (property.DeclaringType == typeof(CompletionItem))
+            if (property.DeclaringType.IsGenericType && property.DeclaringType.GetGenericTypeDefinition() == typeof(CompletionItem<>))
             {
                 if (property.PropertyType == typeof(CompletionItemKind))
                 {
diff --git a/src/Protocol/Serialization/Converters/CompletionListConverter.cs b/src/Protocol/Serialization/Converters/CompletionListConverter.cs
index 440c9cde8..4f6e84a9c 100644
--- a/src/Protocol/Serialization/Converters/CompletionListConverter.cs
+++ b/src/Protocol/Serialization/Converters/CompletionListConverter.cs
@@ -7,10 +7,16 @@
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Serialization.Converters
 {
-    class CompletionListConverter : JsonConverter<CompletionList>
+    class CompletionListConverter : JsonConverter
     {
-        public override void WriteJson(JsonWriter writer, CompletionList value, JsonSerializer serializer)
+        public override bool CanConvert(Type objectType)
         {
+            return typeof(ICompletionList).IsAssignableFrom(objectType);
+        }
+
+        public override void WriteJson(JsonWriter writer, object v, JsonSerializer serializer)
+        {
+            if (!(v is ICompletionList value)) throw new NotSupportedException("could not convert item to ICompletionList");
             if (!value.IsIncomplete)
             {
                 serializer.Serialize(writer, value.Items.ToArray());
@@ -31,19 +37,36 @@ public override void WriteJson(JsonWriter writer, CompletionList value, JsonSeri
             writer.WriteEndObject();
         }
 
-        public override CompletionList ReadJson(JsonReader reader, Type objectType, CompletionList existingValue, bool hasExistingValue, JsonSerializer serializer)
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
         {
+            Type innerType;
+            Type enumerableType;
+            Type returnType;
+            if (objectType == typeof(CompletionList))
+            {
+                 innerType = typeof(ResolvedData);
+                 enumerableType = typeof(IEnumerable<>).MakeGenericType(typeof(CompletionItem<>).MakeGenericType(innerType));
+                 returnType = typeof(CompletionList);
+            }
+            else
+            {
+                 innerType = objectType.GetGenericArguments()[0];
+                 enumerableType = typeof(IEnumerable<>).MakeGenericType(typeof(CompletionItem<>).MakeGenericType(innerType));
+                 returnType = typeof(CompletionList<>).MakeGenericType(innerType);
+
+            }
             if (reader.TokenType == JsonToken.StartArray)
             {
-                var array = JArray.Load(reader).ToObject<IEnumerable<CompletionItem>>(serializer);
-                return new CompletionList(array);
+                var array = JArray.Load(reader).ToObject(enumerableType, serializer);
+                return Activator.CreateInstance(returnType, array);
             }
 
             var result = JObject.Load(reader);
-            var items = result["items"].ToObject<IEnumerable<CompletionItem>>(serializer);
-            return new CompletionList(items, result["isIncomplete"].Value<bool>());
+            var items = result["items"].ToObject(enumerableType, serializer);
+            return Activator.CreateInstance(returnType, new object[] { items, result["isIncomplete"].Value<bool>() });
         }
 
         public override bool CanRead => true;
+        public override bool CanWrite => true;
     }
 }
diff --git a/src/Protocol/Server/Capabilities/CodeLensOptions.cs b/src/Protocol/Server/Capabilities/CodeLensOptions.cs
index 692ce6ef0..baf191363 100644
--- a/src/Protocol/Server/Capabilities/CodeLensOptions.cs
+++ b/src/Protocol/Server/Capabilities/CodeLensOptions.cs
@@ -21,7 +21,7 @@ public class CodeLensOptions : WorkDoneProgressOptions, ICodeLensOptions
         public static CodeLensOptions Of(ICodeLensOptions options, IEnumerable<IHandlerDescriptor> descriptors)
         {
             return new CodeLensOptions() {
-                ResolveProvider = options.ResolveProvider || descriptors.Any(z => z.HandlerType == typeof(ICodeLensResolveHandler)),
+                ResolveProvider = options.ResolveProvider || descriptors.Any(z => z.HandlerType.IsGenericType && z.HandlerType.GetGenericTypeDefinition() == typeof(ICodeLensResolveHandler<>)),
                 WorkDoneProgress = options.WorkDoneProgress
             };
         }
diff --git a/src/Protocol/Server/Capabilities/CompletionOptions.cs b/src/Protocol/Server/Capabilities/CompletionOptions.cs
index 572bb6b62..020241097 100644
--- a/src/Protocol/Server/Capabilities/CompletionOptions.cs
+++ b/src/Protocol/Server/Capabilities/CompletionOptions.cs
@@ -46,7 +46,7 @@ public static CompletionOptions Of(ICompletionOptions options, IEnumerable<IHand
         {
             return new CompletionOptions()
             {
-                ResolveProvider = options.ResolveProvider || descriptors.Any(z => z.HandlerType == typeof(ICompletionResolveHandler)),
+                ResolveProvider = options.ResolveProvider || descriptors.Any(z => z.HandlerType.IsGenericType && z.HandlerType.GetGenericTypeDefinition() == typeof(ICompletionResolveHandler<>)),
                 AllCommitCharacters = options.AllCommitCharacters,
                 TriggerCharacters = options.TriggerCharacters,
                 WorkDoneProgress = options.WorkDoneProgress,
diff --git a/src/Protocol/Server/Capabilities/DocumentLinkOptions.cs b/src/Protocol/Server/Capabilities/DocumentLinkOptions.cs
index 8e6cae866..8e9c0c7ae 100644
--- a/src/Protocol/Server/Capabilities/DocumentLinkOptions.cs
+++ b/src/Protocol/Server/Capabilities/DocumentLinkOptions.cs
@@ -21,7 +21,7 @@ public class DocumentLinkOptions : WorkDoneProgressOptions, IDocumentLinkOptions
         public static DocumentLinkOptions Of(IDocumentLinkOptions options, IEnumerable<IHandlerDescriptor> descriptors)
         {
             return new DocumentLinkOptions() {
-                ResolveProvider = options.ResolveProvider  || descriptors.Any(z => z.HandlerType == typeof(IDocumentLinkResolveHandler)) ,
+                ResolveProvider = options.ResolveProvider  || descriptors.Any(z => z.HandlerType.IsGenericType && z.HandlerType.GetGenericTypeDefinition() == typeof(IDocumentLinkResolveHandler<>)) ,
                 WorkDoneProgress = options.WorkDoneProgress,
             };
         }
diff --git a/src/Protocol/Shared/ILspHandlerDescriptor.cs b/src/Protocol/Shared/ILspHandlerDescriptor.cs
index 52a30ad7b..8e18ca7be 100644
--- a/src/Protocol/Shared/ILspHandlerDescriptor.cs
+++ b/src/Protocol/Shared/ILspHandlerDescriptor.cs
@@ -17,5 +17,7 @@ public interface ILspHandlerDescriptor : IHandlerDescriptor
         Type CanBeResolvedHandlerType { get; }
         OnServerStartedDelegate OnServerStartedDelegate { get; }
         OnClientStartedDelegate OnClientStartedDelegate { get; }
+        bool CanBeResolved { get; }
+        Type CanBeResolvedDataType { get; }
     }
 }
diff --git a/src/Protocol/Shared/LspHandlerDescriptor.cs b/src/Protocol/Shared/LspHandlerDescriptor.cs
index ef6f6a0f4..5098ce8fa 100644
--- a/src/Protocol/Shared/LspHandlerDescriptor.cs
+++ b/src/Protocol/Shared/LspHandlerDescriptor.cs
@@ -50,7 +50,13 @@ public LspHandlerDescriptor(
             // If multiple are implemented this behavior is unknown
             CanBeResolvedHandlerType = handler.GetType().GetTypeInfo()
                 .ImplementedInterfaces
-                .FirstOrDefault(x => x.GetTypeInfo().IsGenericType && x.GetTypeInfo().GetGenericTypeDefinition() == typeof(ICanBeResolvedHandler<>));
+                .FirstOrDefault(x => x.GetTypeInfo().IsGenericType && x.GetTypeInfo().GetGenericTypeDefinition() == typeof(ICanBeResolvedHandler<,>));
+            CanBeResolvedDataType = CanBeResolvedHandlerType?.GetGenericArguments()[1] ?? (@params.IsGenericType && typeof(CanBeResolvedData).IsAssignableFrom(@params.GetGenericArguments()[0]) ? @params.GetGenericArguments()[0] : null);
+            CanBeResolved = CanBeResolvedHandlerType != null || CanBeResolvedDataType != null;
+            // if (CanBeResolved && !@params.IsGenericType && @params?.BaseType.IsGenericType == true)
+            // {
+            //     Params = @params.BaseType;
+            // }
 
             HasReturnType = HandlerType.GetInterfaces().Any(@interface =>
                 @interface.IsGenericType &&
@@ -91,6 +97,8 @@ public LspHandlerDescriptor(
         public Type CapabilityType { get; }
         public OnServerStartedDelegate OnServerStartedDelegate { get; }
         public OnClientStartedDelegate OnClientStartedDelegate { get; }
+        public bool CanBeResolved { get; }
+        public Type CanBeResolvedDataType { get; }
 
         public string Method { get; }
         public string Key { get; }
diff --git a/src/Server/Matchers/ResolveCommandMatcher.cs b/src/Server/Matchers/ResolveCommandMatcher.cs
index 62a6121f9..49dbbd5eb 100644
--- a/src/Server/Matchers/ResolveCommandMatcher.cs
+++ b/src/Server/Matchers/ResolveCommandMatcher.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -13,8 +14,6 @@ namespace OmniSharp.Extensions.LanguageServer.Server.Matchers
     public class ResolveCommandMatcher : IHandlerMatcher
     {
         private readonly ILogger<ResolveCommandMatcher> _logger;
-        internal static string PrivateHandlerTypeName = "$$___handlerType___$$";
-        internal static string PrivateHandlerKey = "$$___handlerKey___$$";
 
         public ResolveCommandMatcher(ILogger<ResolveCommandMatcher> logger)
         {
@@ -29,34 +28,11 @@ public ResolveCommandMatcher(ILogger<ResolveCommandMatcher> logger)
         /// <returns></returns>
         public IEnumerable<ILspHandlerDescriptor> FindHandler(object parameters, IEnumerable<ILspHandlerDescriptor> descriptors)
         {
-            if (parameters is ICanBeResolved canBeResolved)
+            if (parameters is ICanBeResolved<CanBeResolvedData> canBeResolved)
             {
-                string handlerType = null;
-                string handlerKey = null;
-                if (canBeResolved.Data != null && canBeResolved.Data.Type == JTokenType.Object)
+                var handlerName = canBeResolved.Data?.handler;
+                if (handlerName == null || handlerName == Guid.Empty)
                 {
-                    handlerType = canBeResolved.Data?[PrivateHandlerTypeName]?.ToString();
-                    handlerKey = canBeResolved.Data?[PrivateHandlerKey]?.ToString();
-                }
-
-                if (string.IsNullOrWhiteSpace(handlerType) &&
-                    string.IsNullOrWhiteSpace(handlerKey))
-                {
-                    foreach (var descriptor in descriptors)
-                    {
-                        if (descriptor.Params == parameters.GetType())
-                        // if (descriptor.CanBeResolvedHandlerType?.GetTypeInfo().IsAssignableFrom(descriptor.ImplementationType) == true)
-                        {
-                            var method = CanResolveMethod
-                                .MakeGenericMethod(descriptor.Params);
-                            if ((bool)method.Invoke(null, new[] { descriptor.Handler, parameters }))
-                            {
-                                yield return descriptor;
-                                yield break;
-                            }
-                        }
-                    }
-
                     var descriptor2 = descriptors.FirstOrDefault();
                     _logger.LogTrace(
                         "Resolve {Method} was called, but data did not have handle type defined.  Using Handler {HandlerType}",
@@ -72,23 +48,14 @@ public IEnumerable<ILspHandlerDescriptor> FindHandler(object parameters, IEnumer
                     _logger.LogTrace("Checking handler {Method}:{Handler}",
                         descriptor.Method,
                         descriptor.ImplementationType.FullName);
-                    if ((descriptor.ImplementationType.FullName == handlerType || descriptor.HandlerType.FullName == handlerType) &&
-                        ((descriptor is LspHandlerDescriptor handlerDescriptor) && handlerDescriptor.Key == handlerKey))
+                    if (!(descriptor.Handler is ICanBeIdentifiedHandler handler)) continue;
+
+                    if (handler.Id == handlerName)
                     {
                         yield return descriptor;
                     }
                 }
             }
         }
-
-        private static readonly MethodInfo CanResolveMethod =
-            typeof(ResolveCommandMatcher).GetTypeInfo()
-                .GetMethod(nameof(CanResolve), BindingFlags.NonPublic | BindingFlags.Static);
-
-        private static bool CanResolve<T>(ICanBeResolvedHandler<T> handler, T value)
-            where T : ICanBeResolved, IRequest<T>
-        {
-            return handler.CanResolve(value);
-        }
     }
 }
diff --git a/src/Server/Matchers/TextDocumentMatcher.cs b/src/Server/Matchers/TextDocumentMatcher.cs
index d1c636dc3..559eda8b7 100644
--- a/src/Server/Matchers/TextDocumentMatcher.cs
+++ b/src/Server/Matchers/TextDocumentMatcher.cs
@@ -57,7 +57,7 @@ public IEnumerable<ILspHandlerDescriptor> FindHandler(object parameters, IEnumer
         private List<TextDocumentAttributes> GetTextDocumentAttributes(DocumentUri uri)
         {
             return _textDocumentIdentifiers
-                .Select(x => x.GetTextDocumentAttributes(uri))
+                .SelectMany(x => x.GetTextDocumentAttributes(uri))
                 .Where(x => x != null)
                 .Distinct()
                 .ToList();
diff --git a/src/Server/Pipelines/ResolveCommandPipeline.cs b/src/Server/Pipelines/ResolveCommandPipeline.cs
index ab1c0bc91..1651351ab 100644
--- a/src/Server/Pipelines/ResolveCommandPipeline.cs
+++ b/src/Server/Pipelines/ResolveCommandPipeline.cs
@@ -1,4 +1,6 @@
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
@@ -26,40 +28,27 @@ public ResolveCommandPipeline(IRequestContext context, ILogger<ResolveCommandPip
 
         public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
         {
-            if (request is ICanBeResolved canBeResolved)
-            {
-                string handlerType = null;
-                if (canBeResolved.Data != null && canBeResolved.Data.Type == JTokenType.Object)
-                    handlerType = canBeResolved.Data?[PrivateHandlerTypeName]?.ToString();
-
-                if (!string.IsNullOrWhiteSpace(handlerType))
-                {
-                    canBeResolved.Data = canBeResolved.Data["data"];
-                }
-            }
-
             var response = await next();
             cancellationToken.ThrowIfCancellationRequested();
 
             // Only pin the handler type, if we know the source handler (codelens) is also the resolver.
-            if (_descriptor is LspHandlerDescriptor handlerDescriptor &&
-                response is IEnumerable<ICanBeResolved> canBeResolveds &&
-                _descriptor?.CanBeResolvedHandlerType?.GetTypeInfo().IsAssignableFrom(_descriptor.ImplementationType) == true)
+            if (_descriptor is LspHandlerDescriptor handlerDescriptor && handlerDescriptor.CanBeResolved && response is IEnumerable<object> values)
             {
+                PropertyInfo propertyInfo = null;
                 _logger.LogTrace(
                     "Updating Resolve items with wrapped data for {Method}:{Handler}",
                     _descriptor.Method,
                     _descriptor.ImplementationType.FullName);
-                foreach (var item in canBeResolveds)
+                foreach (var item in values)
                 {
-                    // Originally we were going to change Data to be a JObject instead of JToken
-                    // This allows us to leave data alone by simply wrapping it
-                    // Since we're always going to intercept these items, we can control this.
-                    var data = new JObject();
-                    data["data"] = item.Data;
-                    data[PrivateHandlerTypeName] = _descriptor.ImplementationType.FullName;
-                    data[PrivateHandlerKey] = handlerDescriptor.Key;
-                    item.Data = data;
+                    if (!(item is ICanBeResolved<CanBeResolvedData> value)) continue;
+                    if (value.Data == null)
+                    {
+                        propertyInfo ??= item.GetType().GetProperty(nameof(value.Data));
+                        propertyInfo.SetValue(item, Activator.CreateInstance(propertyInfo.PropertyType));
+                    }
+
+                    value.Data.handler = _descriptor.Handler is ICanBeIdentifiedHandler resolved ? resolved.Id : Guid.Empty;
                 }
             }
 
diff --git a/src/Shared/LspRequestRouter.cs b/src/Shared/LspRequestRouter.cs
index 80d794ec1..c09361f69 100644
--- a/src/Shared/LspRequestRouter.cs
+++ b/src/Shared/LspRequestRouter.cs
@@ -16,7 +16,7 @@ namespace OmniSharp.Extensions.LanguageServer.Shared
     internal class LspRequestRouter : RequestRouterBase<ILspHandlerDescriptor>, IRequestRouter<IHandlerDescriptor>
     {
         private readonly IHandlerCollection _collection;
-        private readonly IEnumerable<IHandlerMatcher> _handlerMatchers;
+        private readonly HashSet<IHandlerMatcher> _handlerMatchers;
 
         public LspRequestRouter(
             IHandlerCollection collection,
@@ -28,25 +28,25 @@ public LspRequestRouter(
             base(serializer, serviceProvider, serviceScopeFactory, loggerFactory.CreateLogger<LspRequestRouter>())
         {
             _collection = collection;
-            _handlerMatchers = handlerMatchers;
+            _handlerMatchers = new HashSet<IHandlerMatcher>(handlerMatchers);
         }
 
-        public override ILspHandlerDescriptor GetDescriptor(Notification notification)
+        public override IRequestDescriptor<ILspHandlerDescriptor> GetDescriptor(Notification notification)
         {
             return FindDescriptor(notification);
         }
 
-        public override ILspHandlerDescriptor GetDescriptor(Request request)
+        public override IRequestDescriptor<ILspHandlerDescriptor> GetDescriptor(Request request)
         {
             return FindDescriptor(request);
         }
 
-        private ILspHandlerDescriptor FindDescriptor(IMethodWithParams instance)
+        private IRequestDescriptor<ILspHandlerDescriptor> FindDescriptor(IMethodWithParams instance)
         {
             return FindDescriptor(instance.Method, instance.Params);
         }
 
-        private ILspHandlerDescriptor FindDescriptor(string method, JToken @params)
+        private IRequestDescriptor<ILspHandlerDescriptor> FindDescriptor(string method, JToken @params)
         {
             _logger.LogDebug("Finding descriptor for {Method}", method);
             var descriptor = _collection.FirstOrDefault(x => x.Method == method);
@@ -57,27 +57,28 @@ private ILspHandlerDescriptor FindDescriptor(string method, JToken @params)
                 return null;
             }
 
-            if (@params == null || descriptor.Params == null) return descriptor;
+            if (@params == null || descriptor.Params == null) return new RequestDescriptor<ILspHandlerDescriptor>(new [] { descriptor });
 
             var lspHandlerDescriptors = _collection.Where(handler => handler.Method == method).ToList();
-            if (lspHandlerDescriptors.Count == 1) return descriptor;
+            if (lspHandlerDescriptors.Count == 1) return new RequestDescriptor<ILspHandlerDescriptor>(lspHandlerDescriptors);
 
             var paramsValue = @params.ToObject(descriptor.Params, _serializer.JsonSerializer);
-            return _handlerMatchers.SelectMany(strat => strat.FindHandler(paramsValue, lspHandlerDescriptors)).FirstOrDefault() ?? descriptor;
+            var matchingDescriptors = _handlerMatchers.SelectMany(strat => strat.FindHandler(paramsValue, lspHandlerDescriptors)).ToArray();
+            return matchingDescriptors.Length == 0 ? new RequestDescriptor<ILspHandlerDescriptor>(new [] { descriptor }) : new RequestDescriptor<ILspHandlerDescriptor>(matchingDescriptors);
         }
 
-        IHandlerDescriptor IRequestRouter<IHandlerDescriptor>.GetDescriptor(Notification notification) => GetDescriptor(notification);
-        IHandlerDescriptor IRequestRouter<IHandlerDescriptor>.GetDescriptor(Request request) => GetDescriptor(request);
+        IRequestDescriptor<IHandlerDescriptor> IRequestRouter<IHandlerDescriptor>.GetDescriptor(Notification notification) => GetDescriptor(notification);
+        IRequestDescriptor<IHandlerDescriptor> IRequestRouter<IHandlerDescriptor>.GetDescriptor(Request request) => GetDescriptor(request);
 
-        Task IRequestRouter<IHandlerDescriptor>.RouteNotification(IHandlerDescriptor descriptor, Notification notification, CancellationToken token) =>
+        Task IRequestRouter<IHandlerDescriptor>.RouteNotification(IRequestDescriptor<IHandlerDescriptor> descriptors, Notification notification, CancellationToken token) =>
             RouteNotification(
-                descriptor is ILspHandlerDescriptor d ? d : throw new Exception("This should really never happen, seriously, only hand this correct descriptors"),
+                descriptors is IRequestDescriptor<ILspHandlerDescriptor> d ? d : throw new Exception("This should really never happen, seriously, only hand this correct descriptors"),
                 notification,
                 token);
 
-        Task<ErrorResponse> IRequestRouter<IHandlerDescriptor>.RouteRequest(IHandlerDescriptor descriptor, Request request, CancellationToken token) =>
+        Task<ErrorResponse> IRequestRouter<IHandlerDescriptor>.RouteRequest(IRequestDescriptor<IHandlerDescriptor> descriptors, Request request, CancellationToken token) =>
             RouteRequest(
-                descriptor is ILspHandlerDescriptor d ? d : throw new Exception("This should really never happen, seriously, only hand this correct descriptors"),
+                descriptors is IRequestDescriptor<ILspHandlerDescriptor> d ? d : throw new Exception("This should really never happen, seriously, only hand this correct descriptors"),
                 request,
                 token);
     }
diff --git a/src/Shared/SharedHandlerCollection.cs b/src/Shared/SharedHandlerCollection.cs
index a583010b5..425d7fa26 100644
--- a/src/Shared/SharedHandlerCollection.cs
+++ b/src/Shared/SharedHandlerCollection.cs
@@ -203,7 +203,7 @@ private LspHandlerDescriptor GetDescriptor(string method, Type handlerType, IJso
                 // In some scenarios, users will implement both the main handler and the resolve handler to the same class
                 // This allows us to get a key for those interfaces so we can register many resolve handlers
                 // and then route those resolve requests to the correct handler
-                if (handler.GetType().GetTypeInfo().ImplementedInterfaces.Any(x => x.GetTypeInfo().IsGenericType && x.GetTypeInfo().GetGenericTypeDefinition() == typeof(ICanBeResolvedHandler<>)))
+                if (handler.GetType().GetTypeInfo().ImplementedInterfaces.Any(x => x.GetTypeInfo().IsGenericType && x.GetTypeInfo().GetGenericTypeDefinition() == typeof(ICanBeResolvedHandler<,>)))
                 {
                     key = handlerRegistration?.GetRegistrationOptions()?.DocumentSelector ?? key;
                 }
@@ -211,6 +211,11 @@ private LspHandlerDescriptor GetDescriptor(string method, Type handlerType, IJso
 
             if (string.IsNullOrWhiteSpace(key)) key = "default";
 
+            if (handler is ICanBeIdentifiedHandler identifiedHandler && identifiedHandler.Id != Guid.Empty)
+            {
+                key += ":" + identifiedHandler.Id.ToString("N");
+            }
+
             var requestProcessType =
                 options?.RequestProcessType ??
                 typeDescriptor?.RequestProcessType ??
@@ -244,7 +249,20 @@ public bool ContainsHandler(Type type)
 
         public bool ContainsHandler(TypeInfo typeInfo)
         {
-            return this.Any(z => z.HandlerType.GetTypeInfo().IsAssignableFrom(typeInfo) || z.ImplementationType.GetTypeInfo().IsAssignableFrom(typeInfo));
+            if (typeInfo.IsGenericType && typeof(CanBeResolvedData).IsAssignableFrom(typeInfo.GenericTypeArguments[0]))
+            {
+                var type = typeInfo.GenericTypeArguments[0];
+                var typeDefinition = typeInfo.GetGenericTypeDefinition();
+                return this.Any(z =>
+                    z.Params.IsGenericType &&
+                    type.IsAssignableFrom(z.CanBeResolvedDataType) &&
+                    typeDefinition.MakeGenericType(z.CanBeResolvedDataType).GetInterfaces().Any(x => z.HandlerType.IsAssignableFrom(x))
+                );
+            }
+            return this.Any(z =>
+                z.HandlerType.GetTypeInfo().IsAssignableFrom(typeInfo)
+                || z.ImplementationType.GetTypeInfo().IsAssignableFrom(typeInfo)
+            );
         }
 
         private static object GetRegistration<T>(IRegistration<T> registration)
diff --git a/test/Client.Tests/ClientTests.cs b/test/Client.Tests/ClientTests.cs
index 4777e53b6..6f4ef6ccf 100644
--- a/test/Client.Tests/ClientTests.cs
+++ b/test/Client.Tests/ClientTests.cs
@@ -108,8 +108,8 @@ public async Task Completions_Success()
             const int column = 5;
             var expectedDocumentPath = AbsoluteDocumentPath;
             var expectedDocumentUri = DocumentUri.FromFileSystemPath(expectedDocumentPath);
-            var expectedCompletionItems = new CompletionItem[] {
-                new CompletionItem {
+            var expectedCompletionItems = new CompletionItem<ResolvedData>[] {
+                new CompletionItem<ResolvedData> {
                     Kind = CompletionItemKind.Class,
                     Label = "Class1",
                     TextEdit = new TextEdit {
@@ -135,7 +135,7 @@ public async Task Completions_Success()
                     });
                 },
                 server => {
-                    server.OnCompletion((request, cancellationToken) => {
+                    server.OnCompletion<ResolvedData>((request, cancellationToken) => {
                         Assert.NotNull(request.TextDocument);
 
                         Assert.Equal(expectedDocumentUri, request.TextDocument.Uri);
@@ -143,14 +143,14 @@ public async Task Completions_Success()
                         Assert.Equal(line, request.Position.Line);
                         Assert.Equal(column, request.Position.Character);
 
-                        return Task.FromResult(new CompletionList(
+                        return Task.FromResult(new CompletionList<ResolvedData>(
                             expectedCompletionItems,
                             isIncomplete: true
                         ));
                     }, new CompletionRegistrationOptions());
                 });
 
-            var actualCompletions = await client.TextDocument.RequestCompletion(new CompletionParams() {
+            var actualCompletions = await client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
                 TextDocument = AbsoluteDocumentPath,
                 Position = (line, column),
             }, CancellationToken);
diff --git a/test/JsonRpc.Tests/InputHandlerTests.cs b/test/JsonRpc.Tests/InputHandlerTests.cs
index 0574fcae9..ed3ec30a2 100644
--- a/test/JsonRpc.Tests/InputHandlerTests.cs
+++ b/test/JsonRpc.Tests/InputHandlerTests.cs
@@ -357,7 +357,7 @@ public async Task Should_Parse_Logs(string name, Func<PipeReader> createPipeRead
                 {
                     var count = group.Count(x => x == "request");
                     await incomingRequestRouter.Received(count).RouteRequest(
-                        Arg.Any<IHandlerDescriptor>(),
+                        Arg.Any<IRequestDescriptor<IHandlerDescriptor>>(),
                         Arg.Is<Request>(n => group.Key == n.Method),
                         Arg.Any<CancellationToken>()
                     );
@@ -367,7 +367,7 @@ await incomingRequestRouter.Received(count).RouteRequest(
                 {
                     var count = group.Count(x => x == "notification");
                     await incomingRequestRouter.Received(count).RouteNotification(
-                        Arg.Any<IHandlerDescriptor>(),
+                        Arg.Any<IRequestDescriptor<IHandlerDescriptor>>(),
                         Arg.Is<Notification>(n => group.Key == n.Method),
                         Arg.Any<CancellationToken>()
                     );
diff --git a/test/Lsp.Tests/CompletionItemKindTests.cs b/test/Lsp.Tests/CompletionItemKindTests.cs
index 01f63a8eb..197fc692b 100644
--- a/test/Lsp.Tests/CompletionItemKindTests.cs
+++ b/test/Lsp.Tests/CompletionItemKindTests.cs
@@ -13,11 +13,11 @@ public class CompletionItemKindTests
         public void DefaultBehavior_Should_Only_Support_InitialCompletionItemKinds()
         {
             var serializer = new Serializer();
-            var json = serializer.SerializeObject(new CompletionItem() {
+            var json = serializer.SerializeObject(new CompletionItem<ResolvedData>() {
                 Kind = CompletionItemKind.Event
             });
 
-            var result = serializer.DeserializeObject<CompletionItem>(json);
+            var result = serializer.DeserializeObject<CompletionItem<ResolvedData>>(json);
             result.Kind.Should().Be(CompletionItemKind.Event);
         }
 
@@ -25,11 +25,11 @@ public void DefaultBehavior_Should_Only_Support_InitialCompletionItemKinds()
         public void DefaultBehavior_Should_Only_Support_InitialCompletionItemTags()
         {
             var serializer = new Serializer();
-            var json = serializer.SerializeObject(new CompletionItem() {
+            var json = serializer.SerializeObject(new CompletionItem<ResolvedData>() {
                 Tags = new Container<CompletionItemTag>(CompletionItemTag.Deprecated)
             });
 
-            var result = serializer.DeserializeObject<CompletionItem>(json);
+            var result = serializer.DeserializeObject<CompletionItem<ResolvedData>>(json);
             result.Tags.Should().Contain(CompletionItemTag.Deprecated);
         }
 
@@ -48,11 +48,11 @@ public void CustomBehavior_When_CompletionItemKinds_Defined_By_Client()
                 }
             });
 
-            var json = serializer.SerializeObject(new CompletionItem() {
+            var json = serializer.SerializeObject(new CompletionItem<ResolvedData>() {
                 Kind = CompletionItemKind.Event
             });
 
-            var result = serializer.DeserializeObject<CompletionItem>(json);
+            var result = serializer.DeserializeObject<CompletionItem<ResolvedData>>(json);
             result.Kind.Should().Be(CompletionItemKind.Class);
         }
 
@@ -73,11 +73,11 @@ public void CustomBehavior_When_CompletionItemTags_Defined_By_Client()
                 }
             });
 
-            var json = serializer.SerializeObject(new CompletionItem() {
+            var json = serializer.SerializeObject(new CompletionItem<ResolvedData>() {
                 Tags = new Container<CompletionItemTag>(CompletionItemTag.Deprecated)
             });
 
-            var result = serializer.DeserializeObject<CompletionItem>(json);
+            var result = serializer.DeserializeObject<CompletionItem<ResolvedData>>(json);
             result.Tags.Should().BeEmpty();
         }
     }
diff --git a/test/Lsp.Tests/FoundationTests.cs b/test/Lsp.Tests/FoundationTests.cs
index 942030833..6a1511995 100644
--- a/test/Lsp.Tests/FoundationTests.cs
+++ b/test/Lsp.Tests/FoundationTests.cs
@@ -397,7 +397,7 @@ public class ParamsShouldHaveMethodAttributeData : TheoryData<Type>
         {
             public ParamsShouldHaveMethodAttributeData()
             {
-                foreach (var type in typeof(CompletionParams).Assembly.ExportedTypes.Where(z =>
+                foreach (var type in typeof(CompletionParams<ResolvedData>).Assembly.ExportedTypes.Where(z =>
                     z.IsClass && !z.IsAbstract && z.GetInterfaces().Any(z => z.IsGenericType && typeof(IRequest<>).IsAssignableFrom(z.GetGenericTypeDefinition()))))
                 {
                     Add(type);
@@ -409,7 +409,7 @@ public class HandlersShouldHaveMethodAttributeData : TheoryData<Type>
         {
             public HandlersShouldHaveMethodAttributeData()
             {
-                foreach (var type in typeof(CompletionParams).Assembly.ExportedTypes.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z) && !z.IsGenericType)
+                foreach (var type in typeof(CompletionParams<ResolvedData>).Assembly.ExportedTypes.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z) && !z.IsGenericType)
                     .Except(new[] {typeof(ITextDocumentSyncHandler)}))
                 {
                     Add(type);
@@ -421,7 +421,7 @@ public class TypeHandlerData : TheoryData<ILspHandlerTypeDescriptor>
         {
             public TypeHandlerData()
             {
-                foreach (var type in typeof(CompletionParams).Assembly.ExportedTypes.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z) && !z.IsGenericType)
+                foreach (var type in typeof(CompletionParams<ResolvedData>).Assembly.ExportedTypes.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z) && !z.IsGenericType)
                     .Except(new[] {typeof(ITextDocumentSyncHandler)}))
                 {
                     Add(LspHandlerTypeDescriptorHelper.GetHandlerTypeDescriptor(type));
@@ -439,7 +439,7 @@ public class TypeHandlerExtensionData : TheoryData<ILspHandlerTypeDescriptor, st
 
             public TypeHandlerExtensionData()
             {
-                foreach (var type in typeof(CompletionParams).Assembly.ExportedTypes
+                foreach (var type in typeof(CompletionParams<ResolvedData>).Assembly.ExportedTypes
                     .Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z) && !z.IsGenericType)
                     .Except(new[] {typeof(ITextDocumentSyncHandler)}))
                 {
diff --git a/test/Lsp.Tests/HandlerResolverTests.cs b/test/Lsp.Tests/HandlerResolverTests.cs
index 05acef73c..451c255a8 100644
--- a/test/Lsp.Tests/HandlerResolverTests.cs
+++ b/test/Lsp.Tests/HandlerResolverTests.cs
@@ -194,8 +194,8 @@ public void Should_DealWithClassesThatImplementMultipleHandlers_WithoutConflicti
         [Fact]
         public void Should_DealWithClassesThatImplementMultipleHandlers_BySettingKeyAccordingly()
         {
-            var codeLensHandler = Substitute.For(new Type[] { typeof(ICodeLensHandler), typeof(ICodeLensResolveHandler) }, new object[0]);
-            ((ICodeLensHandler)codeLensHandler).GetRegistrationOptions()
+            var codeLensHandler = Substitute.For(new Type[] { typeof(ICodeLensHandler<ResolvedData>), typeof(ICodeLensResolveHandler<ResolvedData>) }, new object[0]);
+            ((ICodeLensHandler<ResolvedData>)codeLensHandler).GetRegistrationOptions()
                 .Returns(new CodeLensRegistrationOptions() {
                     DocumentSelector = new DocumentSelector(DocumentFilter.ForLanguage("foo"))
                 });
@@ -209,24 +209,24 @@ public void Should_DealWithClassesThatImplementMultipleHandlers_BySettingKeyAcco
 
         public static IEnumerable<object[]> Should_DealWithClassesThatImplementMultipleHandlers_WithoutConflictingRegistrations_Data()
         {
-            var codeLensHandler = Substitute.For(new Type[] { typeof(ICodeLensHandler), typeof(ICodeLensResolveHandler) }, new object[0]);
-            ((ICodeLensHandler)codeLensHandler).GetRegistrationOptions()
+            var codeLensHandler = Substitute.For(new Type[] { typeof(ICodeLensHandler<ResolvedData>), typeof(ICodeLensResolveHandler<ResolvedData>) }, new object[0]);
+            ((ICodeLensHandler<ResolvedData>)codeLensHandler).GetRegistrationOptions()
                     .Returns(new CodeLensRegistrationOptions() {
                         DocumentSelector = new DocumentSelector() { }
                     });
 
             yield return new object[] { TextDocumentNames.CodeLensResolve, codeLensHandler };
 
-            var documentLinkHandler = Substitute.For(new Type[] { typeof(IDocumentLinkHandler), typeof(IDocumentLinkResolveHandler) }, new object[0]);
-            ((IDocumentLinkHandler)documentLinkHandler).GetRegistrationOptions()
+            var documentLinkHandler = Substitute.For(new Type[] { typeof(IDocumentLinkHandler<ResolvedData>), typeof(IDocumentLinkResolveHandler<ResolvedData>) }, new object[0]);
+            ((IDocumentLinkHandler<ResolvedData>)documentLinkHandler).GetRegistrationOptions()
                 .Returns(new DocumentLinkRegistrationOptions() {
                     DocumentSelector = new DocumentSelector() { }
                 });
 
             yield return new object[] { TextDocumentNames.DocumentLinkResolve, documentLinkHandler };
 
-            var completionHandler = Substitute.For(new Type[] { typeof(ICompletionHandler), typeof(ICompletionResolveHandler) }, new object[0]);
-            ((ICompletionHandler)completionHandler).GetRegistrationOptions()
+            var completionHandler = Substitute.For(new Type[] { typeof(ICompletionHandler<ResolvedData>), typeof(ICompletionResolveHandler<ResolvedData>) }, new object[0]);
+            ((ICompletionHandler<ResolvedData>)completionHandler).GetRegistrationOptions()
                 .Returns(new CompletionRegistrationOptions() {
                     DocumentSelector = new DocumentSelector() { }
                 });
diff --git a/test/Lsp.Tests/Integration/DynamicRegistrationTests.cs b/test/Lsp.Tests/Integration/DynamicRegistrationTests.cs
index 7194c4fad..11acd9d0b 100644
--- a/test/Lsp.Tests/Integration/DynamicRegistrationTests.cs
+++ b/test/Lsp.Tests/Integration/DynamicRegistrationTests.cs
@@ -51,8 +51,8 @@ public async Task Should_Register_Dynamically_While_Server_Is_Running()
             await Events.SettleNext();
 
             server.Register(x => x
-                .OnCompletion(
-                    (@params, token) => Task.FromResult(new CompletionList()),
+                .OnCompletion<ResolvedData>(
+                    async (@params, token) => new CompletionList(),
                     registrationOptions: new CompletionRegistrationOptions() {
                         DocumentSelector = DocumentSelector.ForLanguage("vb")
                     })
@@ -74,8 +74,8 @@ public async Task Should_Unregister_Dynamically_While_Server_Is_Running()
 
             await Events.SettleNext();
 
-            var disposable = server.Register(x => x.OnCompletion(
-                (@params, token) => Task.FromResult(new CompletionList()),
+            var disposable = server.Register(x => x.OnCompletion<ResolvedData>(
+                async (@params, token) => new CompletionList(),
                 registrationOptions: new CompletionRegistrationOptions() {
                     DocumentSelector = DocumentSelector.ForLanguage("vb")
                 })
@@ -209,8 +209,8 @@ private void ConfigureClient(LanguageClientOptions options)
 
         private void ConfigureServer(LanguageServerOptions options)
         {
-            options.OnCompletion(
-                (@params, token) => Task.FromResult(new CompletionList()),
+            options.OnCompletion<ResolvedData>(
+                async (@params, token) => Task.FromResult(new CompletionList()),
                 registrationOptions: new CompletionRegistrationOptions() {
                     DocumentSelector = DocumentSelector.ForLanguage("csharp"),
                     ResolveProvider = false,
diff --git a/test/Lsp.Tests/Integration/Handlers/CodeLensHandlerTests.cs b/test/Lsp.Tests/Integration/Handlers/CodeLensHandlerTests.cs
new file mode 100644
index 000000000..13ad609d5
--- /dev/null
+++ b/test/Lsp.Tests/Integration/Handlers/CodeLensHandlerTests.cs
@@ -0,0 +1,654 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Newtonsoft.Json.Linq;
+using NSubstitute;
+using OmniSharp.Extensions.JsonRpc.Testing;
+using OmniSharp.Extensions.LanguageProtocol.Testing;
+using OmniSharp.Extensions.LanguageServer.Client;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Extensions.LanguageServer.Protocol.Document;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+using OmniSharp.Extensions.LanguageServer.Server;
+using Xunit;
+using Xunit.Abstractions;
+using Range = OmniSharp.Extensions.LanguageServer.Protocol.Models.Range;
+
+namespace Lsp.Tests.Integration.Handlers
+{
+    public class CodeLensHandlerTests : LanguageProtocolTestBase
+    {
+        public CodeLensHandlerTests(ITestOutputHelper outputHelper) : base(new JsonRpcTestOptions().ConfigureForXUnit(outputHelper))
+        {
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_CodeLens()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.OnCodeLens<Data>(
+                    async (request, capability, ct) => {
+                        return new CodeLensContainer<Data>(new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1, 1),
+                                    Range = new Range(new Position(1, 1), new Position(1, 2))
+                                }
+                            },
+                            new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2, 2),
+                                    Range = new Range(new Position(2, 2), new Position(2, 3))
+                                }
+                            },
+                            new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3, 3),
+                                    Range = new Range(new Position(3, 3), new Position(3, 4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Position.Should().BeEquivalentTo(new Position(2, 2));
+                        request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2, 2), new Position(2, 3)));
+                        return new CodeLens<Data>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForLanguage("csharp")
+                    }
+                );
+            });
+
+            var codeLens = await client.TextDocument.RequestCodeLens(new CodeLensParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            codeLens.Should().HaveCount(3);
+
+            var cl = codeLens.Skip(1).First();
+            cl.Command.Should().BeNull();
+            cl.Data.Data.Should().ContainKeys("position", "range");
+
+            var resolved = await client.TextDocument.ResolveCodeLens(cl, CancellationToken);
+            resolved.Command.Should().NotBeNull();
+            resolved.Data.Data.Should().ContainKeys("position", "range");
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_CodeLens_With_Known_Model()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.OnCodeLens<Data>(
+                    async (request, capability, ct) => {
+                        return new CodeLensContainer<Data>(new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1, 1),
+                                    Range = new Range(new Position(1, 1), new Position(1, 2))
+                                }
+                            },
+                            new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2, 2),
+                                    Range = new Range(new Position(2, 2), new Position(2, 3))
+                                }
+                            },
+                            new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3, 3),
+                                    Range = new Range(new Position(3, 3), new Position(3, 4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Position.Should().BeEquivalentTo(new Position(2, 2));
+                        request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2, 2), new Position(2, 3)));
+                        request.Data.Position = new Position(3, 3);
+                        return new CodeLens<Data>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForLanguage("csharp")
+                    }
+                );
+            });
+
+            var codeLens = await client.TextDocument.RequestCodeLens(new CodeLensParams<ClientData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            codeLens.Should().HaveCount(3);
+
+            var cl = codeLens.Skip(1).First();
+            cl.Command.Should().BeNull();
+            cl.Data.Position.Should().BeEquivalentTo(new Position(2, 2));
+
+            var resolved = await client.TextDocument.ResolveCodeLens(cl, CancellationToken);
+            resolved.Command.Should().NotBeNull();
+            resolved.Data.Position.Should().BeEquivalentTo(new Position(3, 3));
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_CodeLens_With_Different_Data_Models()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+                options.OnCodeLens<Data>(
+                    async (request, capability, ct) => {
+                        return new CodeLensContainer<Data>(new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1, 1),
+                                    Range = new Range(new Position(1, 1), new Position(1, 2))
+                                }
+                            },
+                            new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2, 2),
+                                    Range = new Range(new Position(2, 2), new Position(2, 3))
+                                }
+                            },
+                            new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3, 3),
+                                    Range = new Range(new Position(3, 3), new Position(3, 4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Position.Should().BeEquivalentTo(new Position(2, 2));
+                        request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2, 2), new Position(2, 3)));
+                        request.Data.Position = new Position(3, 3);
+                        return new CodeLens<Data>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
+                    }
+                );
+                options.OnCodeLens<DataSecond>(
+                    async (request, capability, ct) => {
+                        return new CodeLensContainer<DataSecond>(new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "1",
+                                }
+                            },
+                            new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "2",
+                                }
+                            },
+                            new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "3",
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Id.Should().Be("2");
+
+                        return new CodeLens<DataSecond>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForPattern("**/*.vb")
+                    }
+                );
+            });
+
+            var codeLensCs = await client.TextDocument.RequestCodeLens(new CodeLensParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+            var codeLensVb = await client.TextDocument.RequestCodeLens(new CodeLensParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.vb"))
+            }, CancellationToken);
+
+            codeLensCs.Should().HaveCount(3);
+            codeLensVb.Should().HaveCount(3);
+            codeLensCs.Should().NotBeEquivalentTo(codeLensVb);
+
+            var clCs = codeLensCs.Skip(1).First();
+            clCs.Command.Should().BeNull();
+            clCs.Data.Data.Should().ContainKeys("position", "range");
+
+            var clVb = codeLensVb.Skip(1).First();
+            clVb.Command.Should().BeNull();
+            clVb.Data.Data.Should().ContainKeys("id");
+
+            var resolvedCs = await client.TextDocument.ResolveCodeLens(clCs, CancellationToken);
+            resolvedCs.Command.Should().NotBeNull();
+            resolvedCs.Should().BeEquivalentTo(clCs, x => x.Excluding(x => x.Command));
+
+            var resolvedVb = await client.TextDocument.ResolveCodeLens(clVb, CancellationToken);
+            resolvedVb.Command.Should().NotBeNull();
+            resolvedVb.Should().BeEquivalentTo(clVb, x => x.Excluding(x => x.Command));
+        }
+
+
+        [Fact]
+        public async Task Should_Return_And_Aggregate_CodeLens_With_Different_Data_Models_But_Same_Selector()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+                options.OnCodeLens<Data>(
+                    async (request, capability, ct) => {
+                        return new CodeLensContainer<Data>(new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1, 1),
+                                    Range = new Range(new Position(1, 1), new Position(1, 2))
+                                }
+                            },
+                            new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2, 2),
+                                    Range = new Range(new Position(2, 2), new Position(2, 3))
+                                }
+                            },
+                            new CodeLens<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3, 3),
+                                    Range = new Range(new Position(3, 3), new Position(3, 4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Position.Should().BeEquivalentTo(new Position(2, 2));
+                        request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2, 2), new Position(2, 3)));
+                        request.Data.Position = new Position(3, 3);
+
+                        return new CodeLens<Data>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
+                    }
+                );
+                options.OnCodeLens<DataSecond>(
+                    async (request, capability, ct) => {
+                        return new CodeLensContainer<DataSecond>(new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "1",
+                                }
+                            },
+                            new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "2",
+                                }
+                            },
+                            new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "3",
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Id.Should().Be("2");
+                        return new CodeLens<DataSecond>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
+                    }
+                );
+            });
+
+            var codeLensCs = await client.TextDocument.RequestCodeLens(new CodeLensParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            codeLensCs.Should().HaveCount(6);
+
+            codeLensCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("position") && z.Data.Data.Keys.Contains("range")));
+            codeLensCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("id")));
+        }
+
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_CodeLens_Using_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.WithHandler(new DataCodeLensHandler(new CodeLensContainer<Data>(new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForLanguage("csharp")
+                    }
+                ));
+            });
+
+            var codeLens = await client.TextDocument.RequestCodeLens(new CodeLensParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            codeLens.Should().HaveCount(3);
+
+            var cl = codeLens.Skip(1).First();
+            cl.Command.Should().BeNull();
+            cl.Data.Data.Should().ContainKeys("position", "range");
+
+            var resolved = await client.TextDocument.ResolveCodeLens(cl, CancellationToken);
+            resolved.Command.Should().NotBeNull();
+            resolved.Data.Data.Should().ContainKeys("position", "range");
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_CodeLens_With_Known_Model_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.WithHandler(new DataCodeLensHandler(new CodeLensContainer<Data>(new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForLanguage("csharp")
+                    }
+                ));
+            });
+
+            var codeLens = await client.TextDocument.RequestCodeLens(new CodeLensParams<ClientData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            codeLens.Should().HaveCount(3);
+
+            var cl = codeLens.Skip(1).First();
+            cl.Command.Should().BeNull();
+            cl.Data.Position.Should().BeEquivalentTo(new Position(2, 2));
+
+            var resolved = await client.TextDocument.ResolveCodeLens(cl, CancellationToken);
+            resolved.Command.Should().NotBeNull();
+            resolved.Data.Position.Should().BeEquivalentTo(new Position(3, 3));
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_CodeLens_With_Different_Data_Models_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+
+                options.WithHandler(new DataCodeLensHandler(new CodeLensContainer<Data>(new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector =  DocumentSelector.ForPattern("**/*.cs")
+                    }
+                ));
+                options.WithHandler(new DataSecondCodeLensHandler(new CodeLensContainer<DataSecond>(new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "1",
+                                }
+                            },
+                            new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "2",
+                                }
+                            },
+                            new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "3",
+                                }
+                            }),
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForPattern("**/*.vb")
+                    }
+                ));
+            });
+
+            var codeLensCs = await client.TextDocument.RequestCodeLens(new CodeLensParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+            var codeLensVb = await client.TextDocument.RequestCodeLens(new CodeLensParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.vb"))
+            }, CancellationToken);
+
+            codeLensCs.Should().HaveCount(3);
+            codeLensVb.Should().HaveCount(3);
+            codeLensCs.Should().NotBeEquivalentTo(codeLensVb);
+
+            var clCs = codeLensCs.Skip(1).First();
+            clCs.Command.Should().BeNull();
+            clCs.Data.Data.Should().ContainKeys("position", "range");
+
+            var clVb = codeLensVb.Skip(1).First();
+            clVb.Command.Should().BeNull();
+            clVb.Data.Data.Should().ContainKeys("id");
+
+            var resolvedCs = await client.TextDocument.ResolveCodeLens(clCs, CancellationToken);
+            resolvedCs.Command.Should().NotBeNull();
+            resolvedCs.Should().BeEquivalentTo(clCs, x => x.Excluding(x => x.Command));
+
+            var resolvedVb = await client.TextDocument.ResolveCodeLens(clVb, CancellationToken);
+            resolvedVb.Command.Should().NotBeNull();
+            resolvedVb.Should().BeEquivalentTo(clVb, x => x.Excluding(x => x.Command));
+        }
+
+
+        [Fact]
+        public async Task Should_Return_And_Aggregate_CodeLens_With_Different_Data_Models_But_Same_Selector_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+
+                options.WithHandler(new DataCodeLensHandler(new CodeLensContainer<Data>(new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new CodeLens<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector =  DocumentSelector.ForPattern("**/*.cs")
+                    }
+                ));
+                options.WithHandler(new DataSecondCodeLensHandler(new CodeLensContainer<DataSecond>(new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "1",
+                                }
+                            },
+                            new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "2",
+                                }
+                            },
+                            new CodeLens<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "3",
+                                }
+                            }),
+                    new CodeLensRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
+                    }
+                ));
+            });
+
+            var codeLensCs = await client.TextDocument.RequestCodeLens(new CodeLensParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            codeLensCs.Should().HaveCount(6);
+
+            codeLensCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("position") && z.Data.Data.Keys.Contains("range")));
+            codeLensCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("id")));
+        }
+
+        // custom data
+        // resolve custom data
+        // resolve as resolved data
+
+        // add two different types and negotiate with resolve
+
+        private void ConfigureClient(LanguageClientOptions options)
+        {
+        }
+
+        class Data : CanBeResolvedData
+        {
+            public Position Position { get; set; }
+            public Range Range { get; set; }
+        }
+
+        class DataCodeLensHandler : CodeLensHandler<Data>
+        {
+            private readonly CodeLensContainer<Data> _container;
+
+            public DataCodeLensHandler(CodeLensContainer<Data> container, CodeLensRegistrationOptions registrationOptions) : base(registrationOptions)
+            {
+                _container = container;
+                registrationOptions.ResolveProvider = true;
+            }
+
+            public override async Task<CodeLensContainer<Data>> Handle(CodeLensParams<Data> request, CancellationToken cancellationToken) => _container;
+
+            public override async Task<CodeLens<Data>> Handle(CodeLens<Data> request, CancellationToken cancellationToken)
+            {
+                request.Data.Position.Should().BeEquivalentTo(new Position(2, 2));
+                request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2, 2), new Position(2, 3)));
+                request.Data.Position = new Position(3, 3);
+
+                return new CodeLens<Data>() {
+                    Command = new Command() {
+                        Arguments = new JArray(),
+                        Name = "my command",
+                        Title = "My Command"
+                    },
+                    Data = request.Data,
+                    Range = request.Range
+                };
+            }
+        }
+
+        class DataSecondCodeLensHandler : CodeLensHandler<DataSecond>
+        {
+            private readonly CodeLensContainer<DataSecond> _container;
+
+            public DataSecondCodeLensHandler(CodeLensContainer<DataSecond> container, CodeLensRegistrationOptions registrationOptions) : base(registrationOptions)
+            {
+                _container = container;
+                registrationOptions.ResolveProvider = true;
+            }
+
+            public override async Task<CodeLensContainer<DataSecond>> Handle(CodeLensParams<DataSecond> request, CancellationToken cancellationToken) => _container;
+
+            public override async Task<CodeLens<DataSecond>> Handle(CodeLens<DataSecond> request, CancellationToken cancellationToken)
+            {
+                request.Data.Id.Should().Be("2");
+                return new CodeLens<DataSecond>() {
+                    Command = new Command() {
+                        Arguments = new JArray(),
+                        Name = "my command",
+                        Title = "My Command"
+                    },
+                    Data = request.Data,
+                    Range = request.Range
+                };
+            }
+        }
+
+        class DataSecond : CanBeResolvedData
+        {
+            public string Id { get; set; }
+        }
+
+        class ClientData : CanBeResolvedData
+        {
+            public Position Position { get; set; }
+        }
+    }
+}
diff --git a/test/Lsp.Tests/Integration/Handlers/CompletionHandlerTests.cs b/test/Lsp.Tests/Integration/Handlers/CompletionHandlerTests.cs
new file mode 100644
index 000000000..b077e1d34
--- /dev/null
+++ b/test/Lsp.Tests/Integration/Handlers/CompletionHandlerTests.cs
@@ -0,0 +1,642 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Newtonsoft.Json.Linq;
+using NSubstitute;
+using OmniSharp.Extensions.JsonRpc.Testing;
+using OmniSharp.Extensions.LanguageProtocol.Testing;
+using OmniSharp.Extensions.LanguageServer.Client;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Extensions.LanguageServer.Protocol.Document;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Lsp.Tests.Integration.Handlers
+{
+    public class CompletionHandlerTests : LanguageProtocolTestBase
+    {
+        public CompletionHandlerTests(ITestOutputHelper outputHelper)  : base(new JsonRpcTestOptions().ConfigureForXUnit(outputHelper))
+        {
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_Completion()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.OnCompletion<Data>(
+                    async (request, capability, ct) => {
+                        return new CompletionList<Data>(new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1,1),
+                                    Range = new Range(new Position(1,1), new Position(1,2))
+                                }
+                            },
+                            new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2,2),
+                                    Range = new Range(new Position(2,2), new Position(2,3))
+                                }
+                            },
+                            new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3,3),
+                                    Range = new Range(new Position(3,3), new Position(3,4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        AssertionExtensions.Should((object) request.Data.Position).BeEquivalentTo(new Position(2,2));
+                        AssertionExtensions.Should((object) request.Data.Range).BeEquivalentTo(new Range(new Position(2,2), new Position(2,3)));
+                        return new CompletionItem<Data>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                        };
+                    },
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForLanguage("csharp")
+                    }
+                );
+            });
+
+            var Completion = await client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            Completion.Should().HaveCount(3);
+
+            var cl = Completion.Skip(1).First();
+            cl.Command.Should().BeNull();
+            cl.Data.Data.Should().ContainKeys("position", "range");
+
+            var resolved = await client.TextDocument.ResolveCompletion(cl, CancellationToken);
+            resolved.Command.Should().NotBeNull();
+            resolved.Data.Data.Should().ContainKeys("position", "range");
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_Completion_With_Known_Model()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.OnCompletion<Data>(
+                    async (request, capability, ct) => {
+                        return new CompletionList<Data>(new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1,1),
+                                    Range = new Range(new Position(1,1), new Position(1,2))
+                                }
+                            },
+                            new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2,2),
+                                    Range = new Range(new Position(2,2), new Position(2,3))
+                                }
+                            },
+                            new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3,3),
+                                    Range = new Range(new Position(3,3), new Position(3,4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Position.Should().BeEquivalentTo(new Position(2,2));
+                        request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2,2), new Position(2,3)));
+                        request.Data.Position = new Position(3, 3);
+                        return new CompletionItem<Data>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                        };
+                    },
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForLanguage("csharp")
+                    }
+                );
+            });
+
+            var Completion = await client.TextDocument.RequestCompletion(new CompletionParams<ClientData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            Completion.Should().HaveCount(3);
+
+            var cl = Completion.Skip(1).First();
+            cl.Command.Should().BeNull();
+            cl.Data.Position.Should().BeEquivalentTo(new Position(2,2));
+
+            var resolved = await client.TextDocument.ResolveCompletion(cl, CancellationToken);
+            resolved.Command.Should().NotBeNull();
+            resolved.Data.Position.Should().BeEquivalentTo(new Position(3,3));
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_Completion_With_Different_Data_Models()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+                options.OnCompletion<Data>(
+                    async (request, capability, ct) => {
+                        return new CompletionList<Data>(new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1,1),
+                                    Range = new Range(new Position(1,1), new Position(1,2))
+                                }
+                            },
+                            new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2,2),
+                                    Range = new Range(new Position(2,2), new Position(2,3))
+                                }
+                            },
+                            new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3,3),
+                                    Range = new Range(new Position(3,3), new Position(3,4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Position.Should().BeEquivalentTo(new Position(2,2));
+                        request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2,2), new Position(2,3)));
+                        request.Data.Position = new Position(3, 3);
+                        return new CompletionItem<Data>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                        };
+                    },
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForPattern("**/*.cs")
+                    }
+                );
+                options.OnCompletion<DataSecond>(
+                    async (request, capability, ct) => {
+                        return new CompletionList<DataSecond>(new CompletionItem<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "1",
+                                }
+                            },
+                            new CompletionItem<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "2",
+                                }
+                            },
+                            new CompletionItem<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "3",
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Id.Should().Be("2");
+
+                        return new CompletionItem<DataSecond>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                        };
+                    },
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForPattern("**/*.vb")
+                    }
+                );
+            });
+
+            var CompletionCs = await client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+            var CompletionVb = await client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.vb"))
+            }, CancellationToken);
+
+            CompletionCs.Should().HaveCount(3);
+            CompletionVb.Should().HaveCount(3);
+            CompletionCs.Should().NotBeEquivalentTo(CompletionVb);
+
+            var clCs = CompletionCs.Skip(1).First();
+            clCs.Command.Should().BeNull();
+            clCs.Data.Data.Should().ContainKeys("position", "range");
+
+            var clVb = CompletionVb.Skip(1).First();
+            clVb.Command.Should().BeNull();
+            clVb.Data.Data.Should().ContainKeys("id");
+
+            var resolvedCs = await client.TextDocument.ResolveCompletion(clCs, CancellationToken);
+            resolvedCs.Command.Should().NotBeNull();
+            resolvedCs.Should().BeEquivalentTo(clCs, x => x.Excluding(x => x.Command));
+
+            var resolvedVb = await client.TextDocument.ResolveCompletion(clVb, CancellationToken);
+            resolvedVb.Command.Should().NotBeNull();
+            resolvedVb.Should().BeEquivalentTo(clVb, x => x.Excluding(x => x.Command));
+        }
+
+
+        [Fact]
+        public async Task Should_Return_And_Aggregate_Completion_With_Different_Data_Models_But_Same_Selector()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+                options.OnCompletion<Data>(
+                    async (request, capability, ct) => {
+                        return new CompletionList<Data>(new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1,1),
+                                    Range = new Range(new Position(1,1), new Position(1,2))
+                                }
+                            },
+                            new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2,2),
+                                    Range = new Range(new Position(2,2), new Position(2,3))
+                                }
+                            },
+                            new CompletionItem<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3,3),
+                                    Range = new Range(new Position(3,3), new Position(3,4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Position.Should().BeEquivalentTo(new Position(2,2));
+                        request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2,2), new Position(2,3)));
+                        request.Data.Position = new Position(3, 3);
+
+                        return new CompletionItem<Data>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                        };
+                    },
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForPattern("**/*.cs")
+                    }
+                );
+                options.OnCompletion<DataSecond>(
+                    async (request, capability, ct) => {
+                        return new CompletionList<DataSecond>(new CompletionItem<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "1",
+                                }
+                            },
+                            new CompletionItem<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "2",
+                                }
+                            },
+                            new CompletionItem<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "3",
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Id.Should().Be("2");
+                        return new CompletionItem<DataSecond>() {
+                            Command = new Command() {
+                                Arguments = new JArray(),
+                                Name = "my command",
+                                Title = "My Command"
+                            },
+                            Data = request.Data,
+                        };
+                    },
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForPattern("**/*.cs")
+                    }
+                );
+            });
+
+            var CompletionCs = await client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            CompletionCs.Should().HaveCount(6);
+
+            CompletionCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("position") && z.Data.Data.Keys.Contains("range")));
+            CompletionCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("id")));
+        }
+
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_Completion_Using_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.WithHandler(new DataCompletionHandler(new CompletionList<Data>(new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForLanguage("csharp")
+                    }
+                ));
+            });
+
+            var Completion = await client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            Completion.Should().HaveCount(3);
+
+            var cl = Completion.Skip(1).First();
+            cl.Command.Should().BeNull();
+            cl.Data.Data.Should().ContainKeys("position", "range");
+
+            var resolved = await client.TextDocument.ResolveCompletion(cl, CancellationToken);
+            resolved.Command.Should().NotBeNull();
+            resolved.Data.Data.Should().ContainKeys("position", "range");
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_Completion_With_Known_Model_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.WithHandler(new DataCompletionHandler(new CompletionList<Data>(new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForLanguage("csharp")
+                    }
+                ));
+            });
+
+            var Completion = await client.TextDocument.RequestCompletion(new CompletionParams<ClientData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            Completion.Should().HaveCount(3);
+
+            var cl = Completion.Skip(1).First();
+            cl.Command.Should().BeNull();
+            cl.Data.Position.Should().BeEquivalentTo(new Position(2, 2));
+
+            var resolved = await client.TextDocument.ResolveCompletion(cl, CancellationToken);
+            resolved.Command.Should().NotBeNull();
+            resolved.Data.Position.Should().BeEquivalentTo(new Position(3, 3));
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_Completion_With_Different_Data_Models_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+
+                options.WithHandler(new DataCompletionHandler(new CompletionList<Data>(new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector =  DocumentSelector.ForPattern("**/*.cs")
+                    }
+                ));
+                options.WithHandler(new DataSecondCompletionHandler(new CompletionList<DataSecond>(new CompletionItem<DataSecond>() {
+                            Data = new DataSecond() {
+                                Id = "1",
+                            }
+                        },
+                        new CompletionItem<DataSecond>() {
+                            Data = new DataSecond() {
+                                Id = "2",
+                            }
+                        },
+                        new CompletionItem<DataSecond>() {
+                            Data = new DataSecond() {
+                                Id = "3",
+                            }
+                        }),
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForPattern("**/*.vb")
+                    }
+                ));
+            });
+
+            var CompletionCs = await client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+            var CompletionVb = await client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.vb"))
+            }, CancellationToken);
+
+            CompletionCs.Should().HaveCount(3);
+            CompletionVb.Should().HaveCount(3);
+            CompletionCs.Should().NotBeEquivalentTo(CompletionVb);
+
+            var clCs = CompletionCs.Skip(1).First();
+            clCs.Command.Should().BeNull();
+            clCs.Data.Data.Should().ContainKeys("position", "range");
+
+            var clVb = CompletionVb.Skip(1).First();
+            clVb.Command.Should().BeNull();
+            clVb.Data.Data.Should().ContainKeys("id");
+
+            var resolvedCs = await client.TextDocument.ResolveCompletion(clCs, CancellationToken);
+            resolvedCs.Command.Should().NotBeNull();
+            resolvedCs.Should().BeEquivalentTo(clCs, x => x.Excluding(x => x.Command));
+
+            var resolvedVb = await client.TextDocument.ResolveCompletion(clVb, CancellationToken);
+            resolvedVb.Command.Should().NotBeNull();
+            resolvedVb.Should().BeEquivalentTo(clVb, x => x.Excluding(x => x.Command));
+        }
+
+
+        [Fact]
+        public async Task Should_Return_And_Aggregate_Completion_With_Different_Data_Models_But_Same_Selector_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+
+                options.WithHandler(new DataCompletionHandler(new CompletionList<Data>(new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new CompletionItem<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector =  DocumentSelector.ForPattern("**/*.cs")
+                    }
+                ));
+                options.WithHandler(new DataSecondCompletionHandler(new CompletionList<DataSecond>(new CompletionItem<DataSecond>() {
+                            Data = new DataSecond() {
+                                Id = "1",
+                            }
+                        },
+                        new CompletionItem<DataSecond>() {
+                            Data = new DataSecond() {
+                                Id = "2",
+                            }
+                        },
+                        new CompletionItem<DataSecond>() {
+                            Data = new DataSecond() {
+                                Id = "3",
+                            }
+                        }),
+                    new CompletionRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
+                    }
+                ));
+            });
+
+            var CompletionCs = await client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            CompletionCs.Should().HaveCount(6);
+
+            CompletionCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("position") && z.Data.Data.Keys.Contains("range")));
+            CompletionCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("id")));
+        }
+
+        // custom data
+        // resolve custom data
+        // resolve as resolved data
+
+        // add two different types and negotiate with resolve
+
+        private void ConfigureClient(LanguageClientOptions options)
+        {
+        }
+
+        class Data : CanBeResolvedData
+        {
+            public Position Position { get; set; }
+            public Range Range { get; set; }
+        }
+
+        class DataSecond : CanBeResolvedData
+        {
+            public string Id { get; set; }
+        }
+
+        class DataCompletionHandler : CompletionHandler<Data>
+        {
+            private readonly CompletionList<Data> _container;
+
+            public DataCompletionHandler(CompletionList<Data> container, CompletionRegistrationOptions registrationOptions) : base(registrationOptions)
+            {
+                _container = container;
+                registrationOptions.ResolveProvider = true;
+            }
+
+            public override async Task<CompletionList<Data>> Handle(CompletionParams<Data> request, CancellationToken cancellationToken) => _container;
+
+            public override async Task<CompletionItem<Data>> Handle(CompletionItem<Data> request, CancellationToken cancellationToken)
+            {
+                request.Data.Position.Should().BeEquivalentTo(new Position(2,2));
+                request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2,2), new Position(2,3)));
+                request.Data.Position = new Position(3, 3);
+                return new CompletionItem<Data>() {
+                    Command = new Command() {
+                        Arguments = new JArray(),
+                        Name = "my command",
+                        Title = "My Command"
+                    },
+                    Data = request.Data,
+                };
+            }
+        }
+
+        class DataSecondCompletionHandler : CompletionHandler<DataSecond>
+        {
+            private readonly CompletionList<DataSecond> _container;
+
+            public DataSecondCompletionHandler(CompletionList<DataSecond> container, CompletionRegistrationOptions registrationOptions) : base(registrationOptions)
+            {
+                _container = container;
+                registrationOptions.ResolveProvider = true;
+            }
+
+            public override async Task<CompletionList<DataSecond>> Handle(CompletionParams<DataSecond> request, CancellationToken cancellationToken) => _container;
+
+            public override async Task<CompletionItem<DataSecond>> Handle(CompletionItem<DataSecond> request, CancellationToken cancellationToken)
+            {
+                request.Data.Id.Should().Be("2");
+                return new CompletionItem<DataSecond>() {
+                    Command = new Command() {
+                        Arguments = new JArray(),
+                        Name = "my command",
+                        Title = "My Command"
+                    },
+                    Data = request.Data,
+                };
+            }
+        }
+
+        class ClientData : CanBeResolvedData
+        {
+            public Position Position { get; set; }
+        }
+    }
+}
diff --git a/test/Lsp.Tests/Integration/Handlers/DocumentLinkHandlerTests.cs b/test/Lsp.Tests/Integration/Handlers/DocumentLinkHandlerTests.cs
new file mode 100644
index 000000000..54f10f12a
--- /dev/null
+++ b/test/Lsp.Tests/Integration/Handlers/DocumentLinkHandlerTests.cs
@@ -0,0 +1,642 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Newtonsoft.Json.Linq;
+using NSubstitute;
+using OmniSharp.Extensions.JsonRpc.Testing;
+using OmniSharp.Extensions.LanguageProtocol.Testing;
+using OmniSharp.Extensions.LanguageServer.Client;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Extensions.LanguageServer.Protocol.Document;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Lsp.Tests.Integration.Handlers
+{
+    public class DocumentLinkHandlerTests : LanguageProtocolTestBase
+    {
+        public DocumentLinkHandlerTests(ITestOutputHelper outputHelper)  : base(new JsonRpcTestOptions().ConfigureForXUnit(outputHelper))
+        {
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_DocumentLink()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.OnDocumentLink<Data>(
+                    async (request, capability, ct) => {
+                        return new DocumentLinkContainer<Data>(new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1,1),
+                                    Range = new Range(new Position(1,1), new Position(1,2))
+                                }
+                            },
+                            new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2,2),
+                                    Range = new Range(new Position(2,2), new Position(2,3))
+                                }
+                            },
+                            new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3,3),
+                                    Range = new Range(new Position(3,3), new Position(3,4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        AssertionExtensions.Should((object) request.Data.Position).BeEquivalentTo(new Position(2,2));
+                        AssertionExtensions.Should((object) request.Data.Range).BeEquivalentTo(new Range(new Position(2,2), new Position(2,3)));
+                        return new DocumentLink<Data>() {
+                            Target = DocumentUri.File("/some/path"),
+                            Tooltip = "Tooltip",
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForLanguage("csharp")
+                    }
+                );
+            });
+
+            var documentLink = await client.TextDocument.RequestDocumentLink(new DocumentLinkParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            documentLink.Should().HaveCount(3);
+
+            var cl = documentLink.Skip(1).First();
+            cl.Tooltip.Should().BeNull();
+            cl.Target.Should().BeNull();
+            cl.Data.Data.Should().ContainKeys("position", "range");
+
+            var resolved = await client.TextDocument.ResolveDocumentLink(cl, CancellationToken);
+            resolved.Tooltip.Should().NotBeNull();
+            resolved.Target.Should().NotBeNull();
+            resolved.Data.Data.Should().ContainKeys("position", "range");
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_DocumentLink_With_Known_Model()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.OnDocumentLink<Data>(
+                    async (request, capability, ct) => {
+                        return new DocumentLinkContainer<Data>(new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1,1),
+                                    Range = new Range(new Position(1,1), new Position(1,2))
+                                }
+                            },
+                            new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2,2),
+                                    Range = new Range(new Position(2,2), new Position(2,3))
+                                }
+                            },
+                            new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3,3),
+                                    Range = new Range(new Position(3,3), new Position(3,4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Position.Should().BeEquivalentTo(new Position(2,2));
+                        request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2,2), new Position(2,3)));
+                        request.Data.Position = new Position(3, 3);
+                        return new DocumentLink<Data>() {
+                            Target = DocumentUri.File("/some/path"),
+                            Tooltip = "Tooltip",
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForLanguage("csharp")
+                    }
+                );
+            });
+
+            var documentLink = await client.TextDocument.RequestDocumentLink(new DocumentLinkParams<ClientData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            documentLink.Should().HaveCount(3);
+
+            var cl = documentLink.Skip(1).First();
+            cl.Tooltip.Should().BeNull();
+            cl.Target.Should().BeNull();
+            cl.Data.Position.Should().BeEquivalentTo(new Position(2,2));
+
+            var resolved = await client.TextDocument.ResolveDocumentLink(cl, CancellationToken);
+            resolved.Tooltip.Should().NotBeNull();
+            resolved.Target.Should().NotBeNull();
+            resolved.Data.Position.Should().BeEquivalentTo(new Position(3,3));
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_DocumentLink_With_Different_Data_Models()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+                options.OnDocumentLink<Data>(
+                    async (request, capability, ct) => {
+                        return new DocumentLinkContainer<Data>(new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1,1),
+                                    Range = new Range(new Position(1,1), new Position(1,2))
+                                }
+                            },
+                            new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2,2),
+                                    Range = new Range(new Position(2,2), new Position(2,3))
+                                }
+                            },
+                            new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3,3),
+                                    Range = new Range(new Position(3,3), new Position(3,4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Position.Should().BeEquivalentTo(new Position(2,2));
+                        request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2,2), new Position(2,3)));
+                        request.Data.Position = new Position(3, 3);
+                        return new DocumentLink<Data>() {
+                            Target = DocumentUri.File("/some/path"),
+                            Tooltip = "Tooltip",
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForPattern("**/*.cs")
+                    }
+                );
+                options.OnDocumentLink<DataSecond>(
+                    async (request, capability, ct) => {
+                        return new DocumentLinkContainer<DataSecond>(new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "1",
+                                }
+                            },
+                            new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "2",
+                                }
+                            },
+                            new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "3",
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Id.Should().Be("2");
+
+                        return new DocumentLink<DataSecond>() {
+                            Target = DocumentUri.File("/some/path"),
+                            Tooltip = "Tooltip",
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForPattern("**/*.vb")
+                    }
+                );
+            });
+
+            var documentLinkCs = await client.TextDocument.RequestDocumentLink(new DocumentLinkParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+            var documentLinkVb = await client.TextDocument.RequestDocumentLink(new DocumentLinkParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.vb"))
+            }, CancellationToken);
+
+            documentLinkCs.Should().HaveCount(3);
+            documentLinkVb.Should().HaveCount(3);
+            documentLinkCs.Should().NotBeEquivalentTo(documentLinkVb);
+
+            var clCs = documentLinkCs.Skip(1).First();
+            clCs.Tooltip.Should().BeNull();
+            clCs.Target.Should().BeNull();
+            clCs.Data.Data.Should().ContainKeys("position", "range");
+
+            var clVb = documentLinkVb.Skip(1).First();
+            clVb.Tooltip.Should().BeNull();
+            clVb.Target.Should().BeNull();
+            clVb.Data.Data.Should().ContainKeys("id");
+
+            var resolvedCs = await client.TextDocument.ResolveDocumentLink(clCs, CancellationToken);
+            resolvedCs.Tooltip.Should().NotBeNull();
+            resolvedCs.Target.Should().NotBeNull();
+            resolvedCs.Should().BeEquivalentTo(clCs, x => x.Excluding(x => x.Tooltip).Excluding(x => x.Target));
+
+            var resolvedVb = await client.TextDocument.ResolveDocumentLink(clVb, CancellationToken);
+            resolvedVb.Tooltip.Should().NotBeNull();
+            resolvedVb.Target.Should().NotBeNull();
+            resolvedVb.Should().BeEquivalentTo(clVb, x => x.Excluding(x => x.Tooltip).Excluding(x => x.Target));
+        }
+
+
+        [Fact]
+        public async Task Should_Return_And_Aggregate_DocumentLink_With_Different_Data_Models_But_Same_Selector()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+                options.OnDocumentLink<Data>(
+                    async (request, capability, ct) => {
+                        return new DocumentLinkContainer<Data>(new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(1,1),
+                                    Range = new Range(new Position(1,1), new Position(1,2))
+                                }
+                            },
+                            new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(2,2),
+                                    Range = new Range(new Position(2,2), new Position(2,3))
+                                }
+                            },
+                            new DocumentLink<Data>() {
+                                Data = new Data() {
+                                    Position = new Position(3,3),
+                                    Range = new Range(new Position(3,3), new Position(3,4))
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Position.Should().BeEquivalentTo(new Position(2,2));
+                        request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2,2), new Position(2,3)));
+                        request.Data.Position = new Position(3, 3);
+
+                        return new DocumentLink<Data>() {
+                            Target = DocumentUri.File("/some/path"),
+                            Tooltip = "Tooltip",
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForPattern("**/*.cs")
+                    }
+                );
+                options.OnDocumentLink<DataSecond>(
+                    async (request, capability, ct) => {
+                        return new DocumentLinkContainer<DataSecond>(new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "1",
+                                }
+                            },
+                            new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "2",
+                                }
+                            },
+                            new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "3",
+                                }
+                            });
+                    },
+                    async (request, capability, ct) => {
+                        request.Data.Id.Should().Be("2");
+                        return new DocumentLink<DataSecond>() {
+                            Target = DocumentUri.File("/some/path"),
+                            Tooltip = "Tooltip",
+                            Data = request.Data,
+                            Range = request.Range
+                        };
+                    },
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector =DocumentSelector.ForPattern("**/*.cs")
+                    }
+                );
+            });
+
+            var documentLinkCs = await client.TextDocument.RequestDocumentLink(new DocumentLinkParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            documentLinkCs.Should().HaveCount(6);
+
+            documentLinkCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("position") && z.Data.Data.Keys.Contains("range")));
+            documentLinkCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("id")));
+        }
+
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_DocumentLink_Using_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.WithHandler(new DataDocumentLinkHandler(new DocumentLinkContainer<Data>(new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForLanguage("csharp")
+                    }
+                ));
+            });
+
+            var documentLink = await client.TextDocument.RequestDocumentLink(new DocumentLinkParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            documentLink.Should().HaveCount(3);
+
+            var cl = documentLink.Skip(1).First();
+            cl.Tooltip.Should().BeNull();
+            cl.Target.Should().BeNull();
+            cl.Data.Data.Should().ContainKeys("position", "range");
+
+            var resolved = await client.TextDocument.ResolveDocumentLink(cl, CancellationToken);
+            resolved.Tooltip.Should().NotBeNull();
+            resolved.Target.Should().NotBeNull();
+            resolved.Data.Data.Should().ContainKeys("position", "range");
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_DocumentLink_With_Known_Model_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.WithHandler(new DataDocumentLinkHandler(new DocumentLinkContainer<Data>(new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForLanguage("csharp")
+                    }
+                ));
+            });
+
+            var documentLink = await client.TextDocument.RequestDocumentLink(new DocumentLinkParams<ClientData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            documentLink.Should().HaveCount(3);
+
+            var cl = documentLink.Skip(1).First();
+            cl.Tooltip.Should().BeNull();
+            cl.Target.Should().BeNull();
+            cl.Data.Position.Should().BeEquivalentTo(new Position(2, 2));
+
+            var resolved = await client.TextDocument.ResolveDocumentLink(cl, CancellationToken);
+            resolved.Tooltip.Should().NotBeNull();
+            resolved.Target.Should().NotBeNull();
+            resolved.Data.Position.Should().BeEquivalentTo(new Position(3, 3));
+        }
+
+        [Fact]
+        public async Task Should_Return_And_Resolve_DocumentLink_With_Different_Data_Models_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+
+                options.WithHandler(new DataDocumentLinkHandler(new DocumentLinkContainer<Data>(new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector =  DocumentSelector.ForPattern("**/*.cs")
+                    }
+                ));
+                options.WithHandler(new DataSecondDocumentLinkHandler(new DocumentLinkContainer<DataSecond>(new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "1",
+                                }
+                            },
+                            new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "2",
+                                }
+                            },
+                            new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "3",
+                                }
+                            }),
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForPattern("**/*.vb")
+                    }
+                ));
+            });
+
+            var documentLinkCs = await client.TextDocument.RequestDocumentLink(new DocumentLinkParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+            var documentLinkVb = await client.TextDocument.RequestDocumentLink(new DocumentLinkParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.vb"))
+            }, CancellationToken);
+
+            documentLinkCs.Should().HaveCount(3);
+            documentLinkVb.Should().HaveCount(3);
+            documentLinkCs.Should().NotBeEquivalentTo(documentLinkVb);
+
+            var clCs = documentLinkCs.Skip(1).First();
+            clCs.Target.Should().BeNull();
+            clCs.Tooltip.Should().BeNull();
+            clCs.Data.Data.Should().ContainKeys("position", "range");
+
+            var clVb = documentLinkVb.Skip(1).First();
+            clVb.Target.Should().BeNull();
+            clVb.Tooltip.Should().BeNull();
+            clVb.Data.Data.Should().ContainKeys("id");
+
+            var resolvedCs = await client.TextDocument.ResolveDocumentLink(clCs, CancellationToken);
+            resolvedCs.Target.Should().NotBeNull();
+            resolvedCs.Tooltip.Should().NotBeNull();
+            resolvedCs.Should().BeEquivalentTo(clCs, x => x.Excluding(x => x.Target).Excluding(x => x.Tooltip));
+
+            var resolvedVb = await client.TextDocument.ResolveDocumentLink(clVb, CancellationToken);
+            resolvedVb.Target.Should().NotBeNull();
+            resolvedVb.Tooltip.Should().NotBeNull();
+            resolvedVb.Should().BeEquivalentTo(clVb, x => x.Excluding(x => x.Target).Excluding(x => x.Tooltip));
+        }
+
+
+        [Fact]
+        public async Task Should_Return_And_Aggregate_DocumentLink_With_Different_Data_Models_But_Same_Selector_ClassHandler()
+        {
+            var (client, server) = await Initialize(ConfigureClient, options => {
+                options.AddTextDocumentIdentifier(WellKnownLanguages.CSharp, WellKnownLanguages.VisualBasic);
+
+                options.WithHandler(new DataDocumentLinkHandler(new DocumentLinkContainer<Data>(new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(1, 1),
+                                Range = new Range(new Position(1, 1), new Position(1, 2))
+                            }
+                        },
+                        new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(2, 2),
+                                Range = new Range(new Position(2, 2), new Position(2, 3))
+                            }
+                        },
+                        new DocumentLink<Data>() {
+                            Data = new Data() {
+                                Position = new Position(3, 3),
+                                Range = new Range(new Position(3, 3), new Position(3, 4))
+                            }
+                        }),
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector =  DocumentSelector.ForPattern("**/*.cs")
+                    }
+                ));
+                options.WithHandler(new DataSecondDocumentLinkHandler(new DocumentLinkContainer<DataSecond>(new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "1",
+                                }
+                            },
+                            new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "2",
+                                }
+                            },
+                            new DocumentLink<DataSecond>() {
+                                Data = new DataSecond() {
+                                    Id = "3",
+                                }
+                            }),
+                    new DocumentLinkRegistrationOptions() {
+                        DocumentSelector = DocumentSelector.ForPattern("**/*.cs")
+                    }
+                ));
+            });
+
+            var documentLinkCs = await client.TextDocument.RequestDocumentLink(new DocumentLinkParams<ResolvedData>() {
+                TextDocument = new TextDocumentIdentifier(DocumentUri.File("/some/path/file.cs"))
+            }, CancellationToken);
+
+            documentLinkCs.Should().HaveCount(6);
+
+            documentLinkCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("position") && z.Data.Data.Keys.Contains("range")));
+            documentLinkCs.Should().Match(x => x.Any(z => z.Data.Data.Keys.Contains("id")));
+        }
+
+        // custom data
+        // resolve custom data
+        // resolve as resolved data
+
+        // add two different types and negotiate with resolve
+
+        private void ConfigureClient(LanguageClientOptions options)
+        {
+        }
+
+        class Data : CanBeResolvedData
+        {
+            public Position Position { get; set; }
+            public Range Range { get; set; }
+        }
+
+        class DataSecond : CanBeResolvedData
+        {
+            public string Id { get; set; }
+        }
+
+        class DataDocumentLinkHandler : DocumentLinkHandler<Data>
+        {
+            private readonly DocumentLinkContainer<Data> _container;
+
+            public DataDocumentLinkHandler(DocumentLinkContainer<Data> container, DocumentLinkRegistrationOptions registrationOptions) : base(registrationOptions)
+            {
+                _container = container;
+                registrationOptions.ResolveProvider = true;
+            }
+
+            public override async Task<DocumentLinkContainer<Data>> Handle(DocumentLinkParams<Data> request, CancellationToken cancellationToken) => _container;
+
+            public override async Task<DocumentLink<Data>> Handle(DocumentLink<Data> request, CancellationToken cancellationToken)
+            {
+                request.Data.Position.Should().BeEquivalentTo(new Position(2,2));
+                request.Data.Range.Should().BeEquivalentTo(new Range(new Position(2,2), new Position(2,3)));
+                request.Data.Position = new Position(3, 3);
+                return new DocumentLink<Data>() {
+                    Target = DocumentUri.File("/some/path"),
+                    Tooltip = "Tooltip",
+                    Data = request.Data,
+                    Range = request.Range
+                };
+            }
+        }
+
+        class DataSecondDocumentLinkHandler : DocumentLinkHandler<DataSecond>
+        {
+            private readonly DocumentLinkContainer<DataSecond> _container;
+
+            public DataSecondDocumentLinkHandler(DocumentLinkContainer<DataSecond> container, DocumentLinkRegistrationOptions registrationOptions) : base(registrationOptions)
+            {
+                _container = container;
+                registrationOptions.ResolveProvider = true;
+            }
+
+            public override async Task<DocumentLinkContainer<DataSecond>> Handle(DocumentLinkParams<DataSecond> request, CancellationToken cancellationToken) => _container;
+
+            public override async Task<DocumentLink<DataSecond>> Handle(DocumentLink<DataSecond> request, CancellationToken cancellationToken)
+            {
+                request.Data.Id.Should().Be("2");
+                return new DocumentLink<DataSecond>() {
+                    Target = DocumentUri.File("/some/path"),
+                    Tooltip = "Tooltip",
+                    Data = request.Data,
+                    Range = request.Range
+                };
+            }
+        }
+
+        class ClientData : CanBeResolvedData
+        {
+            public Position Position { get; set; }
+        }
+    }
+}
diff --git a/test/Lsp.Tests/Integration/PartialItemTests.cs b/test/Lsp.Tests/Integration/PartialItemTests.cs
index 982131af0..2a7161a56 100644
--- a/test/Lsp.Tests/Integration/PartialItemTests.cs
+++ b/test/Lsp.Tests/Integration/PartialItemTests.cs
@@ -34,7 +34,7 @@ public PartialItemTests(ITestOutputHelper outputHelper) : base(new JsonRpcTestOp
         public async Task Should_Behave_Like_A_Task()
         {
             var (client, server) = await Initialize(ConfigureClient, ConfigureServerWithDelegateCodeLens);
-            var result = await client.TextDocument.RequestCodeLens(new CodeLensParams() {
+            var result = await client.TextDocument.RequestCodeLens(new CodeLensParams<ResolvedData>() {
                 TextDocument = new TextDocumentIdentifier(@"c:\test.cs")
             }, CancellationToken);
 
@@ -47,8 +47,8 @@ public async Task Should_Behave_Like_An_Observable()
         {
             var (client, server) = await Initialize(ConfigureClient, ConfigureServerWithDelegateCodeLens);
 
-            var items = new List<CodeLens>();
-            await client.TextDocument.RequestCodeLens(new CodeLensParams() {
+            var items = new List<ICodeLens<ResolvedData>>();
+            await client.TextDocument.RequestCodeLens(new CodeLensParams<ResolvedData>() {
                 TextDocument = new TextDocumentIdentifier(@"c:\test.cs")
             }, CancellationToken).ForEachAsync(x => items.AddRange(x));
 
@@ -61,11 +61,11 @@ public async Task Should_Behave_Like_An_Observable_With_WorkDone()
         {
             var (client, server) = await Initialize(ConfigureClient, ConfigureServerWithClassCodeLens);
 
-            var items = new List<CodeLens>();
+            var items = new List<ICodeLens<ResolvedData>>();
             var work = new List<WorkDoneProgress>();
             client.TextDocument
                 .ObserveWorkDone(
-                    new CodeLensParams() {TextDocument = new TextDocumentIdentifier(@"c:\test.cs")},
+                    new CodeLensParams<ResolvedData>() {TextDocument = new TextDocumentIdentifier(@"c:\test.cs")},
                     (client, request) => CodeLensExtensions.RequestCodeLens(client, request, CancellationToken),
                     Observer.Create<WorkDoneProgress>(z => work.Add(z))
                 ).Subscribe(x => items.AddRange(x));
@@ -87,23 +87,23 @@ private void ConfigureClient(LanguageClientOptions options)
 
         private void ConfigureServerWithDelegateCodeLens(LanguageServerOptions options)
         {
-            options.OnCodeLens((@params, observer, capability, cancellationToken) => {
+            options.OnCodeLens<ResolvedData>((@params, observer, capability, cancellationToken) => {
                 observer.OnNext(new [] {
-                    new CodeLens() {
+                    new CodeLens<ResolvedData>() {
                         Command = new Command() {
                             Name = "CodeLens 1"
                         }
                     },
                 });
                 observer.OnNext(new [] {
-                    new CodeLens() {
+                    new CodeLens<ResolvedData>() {
                         Command = new Command() {
                             Name = "CodeLens 2"
                         }
                     },
                 });
                 observer.OnNext(new [] {
-                    new CodeLens() {
+                    new CodeLens<ResolvedData>() {
                         Command = new Command() {
                             Name = "CodeLens 3"
                         }
@@ -120,7 +120,7 @@ private void ConfigureServerWithClassCodeLens(LanguageServerOptions options)
             options.AddHandler<InnerCodeLensHandler>();
         }
 
-        class InnerCodeLensHandler : CodeLensHandler
+        class InnerCodeLensHandler : CodeLensHandler<ResolvedData>
         {
             private readonly IServerWorkDoneManager _workDoneManager;
             private readonly IProgressManager _progressManager;
@@ -131,7 +131,7 @@ public InnerCodeLensHandler(IServerWorkDoneManager workDoneManager, IProgressMan
                 _progressManager = progressManager;
             }
 
-            public override async Task<CodeLensContainer> Handle(CodeLensParams request, CancellationToken cancellationToken)
+            public override async Task<CodeLensContainer<ResolvedData>> Handle(CodeLensParams<ResolvedData> request, CancellationToken cancellationToken)
             {
                 var partial = _progressManager.For(request, cancellationToken);
                 var workDone = _workDoneManager.For(request, new WorkDoneProgressBegin() {
@@ -145,7 +145,7 @@ public override async Task<CodeLensContainer> Handle(CodeLensParams request, Can
                 });
 
                 partial.OnNext(new [] {
-                    new CodeLens() {
+                    new CodeLens<ResolvedData>() {
                         Command = new Command() {
                             Name = "CodeLens 1"
                         }
@@ -157,7 +157,7 @@ public override async Task<CodeLensContainer> Handle(CodeLensParams request, Can
                 });
 
                 partial.OnNext(new [] {
-                    new CodeLens() {
+                    new CodeLens<ResolvedData>() {
                         Command = new Command() {
                             Name = "CodeLens 2"
                         }
@@ -169,7 +169,7 @@ public override async Task<CodeLensContainer> Handle(CodeLensParams request, Can
                 });
 
                 partial.OnNext(new [] {
-                    new CodeLens() {
+                    new CodeLens<ResolvedData>() {
                         Command = new Command() {
                             Name = "CodeLens 3"
                         }
@@ -181,7 +181,7 @@ public override async Task<CodeLensContainer> Handle(CodeLensParams request, Can
                 });
 
                 partial.OnNext(new [] {
-                    new CodeLens() {
+                    new CodeLens<ResolvedData>() {
                         Command = new Command() {
                             Name = "CodeLens 4"
                         }
@@ -196,12 +196,10 @@ public override async Task<CodeLensContainer> Handle(CodeLensParams request, Can
 
                 await Task.Yield();
 
-                return new CodeLensContainer();
+                return new CodeLensContainer<ResolvedData>();
             }
 
-            public override Task<CodeLens> Handle(CodeLens request, CancellationToken cancellationToken) => Task.FromResult(request);
-
-            public override bool CanResolve(CodeLens value) => true;
+            public override Task<CodeLens<ResolvedData>> Handle(CodeLens<ResolvedData> request, CancellationToken cancellationToken) => Task.FromResult(request);
         }
 
     }
diff --git a/test/Lsp.Tests/Integration/RequestCancellationTests.cs b/test/Lsp.Tests/Integration/RequestCancellationTests.cs
index 34d80a98d..6fb4b47f1 100644
--- a/test/Lsp.Tests/Integration/RequestCancellationTests.cs
+++ b/test/Lsp.Tests/Integration/RequestCancellationTests.cs
@@ -36,7 +36,7 @@ public async Task Should_Cancel_Pending_Requests()
 
             var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(10));
             CancellationToken.Register(cts.Cancel);
-            Func<Task<CompletionList>> action = () => client.TextDocument.RequestCompletion(new CompletionParams() {
+            Func<Task<CompletionList<ResolvedData>>> action = () => client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
                 TextDocument = "/a/file.cs"
             }, cts.Token).AsTask();
             action.Should().Throw<TaskCanceledException>();
@@ -47,7 +47,7 @@ public async Task Should_Abandon_Pending_Requests_For_Text_Changes()
         {
             var (client, server) = await Initialize(ConfigureClient, ConfigureServer);
 
-            var request1 = client.TextDocument.RequestCompletion(new CompletionParams() {
+            var request1 = client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
                 TextDocument = "/a/file.cs"
             }, CancellationToken).AsTask();
 
@@ -71,7 +71,7 @@ public async Task Should_Cancel_Requests_After_Timeout()
                 x.WithMaximumRequestTimeout(TimeSpan.FromMilliseconds(500));
             });
 
-            Func<Task> action = () => client.TextDocument.RequestCompletion(new CompletionParams() {
+            Func<Task> action = () => client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
                 TextDocument = "/a/file.cs"
             }, CancellationToken).AsTask();
             action.Should().Throw<RequestCancelledException>();
@@ -85,7 +85,7 @@ public async Task Should_Cancel_Requests_After_Timeout_without_Content_Modified(
                 x.WithContentModifiedSupport(false).WithMaximumRequestTimeout(TimeSpan.FromMilliseconds(500));
             });
 
-            Func<Task> action = () => client.TextDocument.RequestCompletion(new CompletionParams() {
+            Func<Task> action = () => client.TextDocument.RequestCompletion(new CompletionParams<ResolvedData>() {
                 TextDocument = "/a/file.cs"
             }, CancellationToken).AsTask();
             action.Should().Throw<RequestCancelledException>();
@@ -135,7 +135,7 @@ private void ConfigureClient(LanguageClientOptions options)
         private void ConfigureServer(LanguageServerOptions options)
         {
             options.WithContentModifiedSupport(true);
-            options.OnCompletion(async (x, ct) => {
+            options.OnCompletion<ResolvedData>(async (x, ct) => {
                 await Task.Delay(50000, ct);
                 return new CompletionList();
             }, new CompletionRegistrationOptions());
diff --git a/test/Lsp.Tests/LspRequestRouterTests.cs b/test/Lsp.Tests/LspRequestRouterTests.cs
index 6e345983e..0e14614d5 100644
--- a/test/Lsp.Tests/LspRequestRouterTests.cs
+++ b/test/Lsp.Tests/LspRequestRouterTests.cs
@@ -86,7 +86,6 @@ public LspRequestRouterTests(ITestOutputHelper testOutputHelper) : base(testOutp
             Services
                 .AddJsonRpcMediatR(new[] {typeof(LspRequestRouterTests).Assembly})
                 .AddSingleton<ISerializer>(new Serializer(ClientVersion.Lsp3));
-            Services.AddTransient<IHandlerMatcher, TextDocumentMatcher>();
         }
 
         [Fact]
@@ -102,6 +101,7 @@ public async Task ShouldRouteToCorrect_Notification()
                     {textDocumentSyncHandler};
             AutoSubstitute.Provide<IHandlerCollection>(collection);
             AutoSubstitute.Provide<IEnumerable<ILspHandlerDescriptor>>(collection);
+            AutoSubstitute.Provide<IHandlerMatcher>(AutoSubstitute.Resolve<TextDocumentMatcher>());
             var mediator = AutoSubstitute.Resolve<LspRequestRouter>();
 
             var @params = new DidSaveTextDocumentParams() {
@@ -136,6 +136,7 @@ public async Task ShouldRouteToCorrect_Notification_WithManyHandlers()
                     {textDocumentSyncHandler, textDocumentSyncHandler2};
             AutoSubstitute.Provide<IHandlerCollection>(collection);
             AutoSubstitute.Provide<IEnumerable<ILspHandlerDescriptor>>(collection);
+            AutoSubstitute.Provide<IHandlerMatcher>(AutoSubstitute.Resolve<TextDocumentMatcher>());
             var mediator = AutoSubstitute.Resolve<LspRequestRouter>();
 
             var @params = new DidSaveTextDocumentParams() {
@@ -173,6 +174,7 @@ public async Task ShouldRouteToCorrect_Request()
                     {textDocumentSyncHandler, codeActionHandler};
             AutoSubstitute.Provide<IHandlerCollection>(collection);
             AutoSubstitute.Provide<IEnumerable<ILspHandlerDescriptor>>(collection);
+            AutoSubstitute.Provide<IHandlerMatcher>(AutoSubstitute.Resolve<TextDocumentMatcher>());
             var mediator = AutoSubstitute.Resolve<LspRequestRouter>();
 
             var id = Guid.NewGuid().ToString();
@@ -225,6 +227,7 @@ public async Task ShouldRouteToCorrect_Request_WithManyHandlers()
             handlerCollection.Add(registry.Handlers);
             AutoSubstitute.Provide<IHandlerCollection>(handlerCollection);
             AutoSubstitute.Provide<IEnumerable<ILspHandlerDescriptor>>(handlerCollection);
+            AutoSubstitute.Provide<IHandlerMatcher>(AutoSubstitute.Resolve<TextDocumentMatcher>());
             var mediator = AutoSubstitute.Resolve<LspRequestRouter>();
 
             var id = Guid.NewGuid().ToString();
@@ -253,29 +256,30 @@ public async Task ShouldRouteToCorrect_Request_WithManyHandlers_CodeLensHandler(
             textDocumentSyncHandler2.Handle(Arg.Any<DidSaveTextDocumentParams>(), Arg.Any<CancellationToken>())
                 .Returns(Unit.Value);
 
-            var codeActionHandler = Substitute.For<ICodeLensHandler>();
+            var codeActionHandler = Substitute.For<ICodeLensHandler<ResolvedData>>();
             codeActionHandler.GetRegistrationOptions().Returns(new CodeLensRegistrationOptions()
                 {DocumentSelector = DocumentSelector.ForPattern("**/*.cs")});
             codeActionHandler
-                .Handle(Arg.Any<CodeLensParams>(), Arg.Any<CancellationToken>())
-                .Returns(new CodeLensContainer());
+                .Handle(Arg.Any<CodeLensParams<ResolvedData>>(), Arg.Any<CancellationToken>())
+                .Returns(new CodeLensContainer<ResolvedData>());
 
-            var codeActionHandler2 = Substitute.For<ICodeLensHandler>();
+            var codeActionHandler2 = Substitute.For<ICodeLensHandler<ResolvedData>>();
             codeActionHandler2.GetRegistrationOptions().Returns(new CodeLensRegistrationOptions()
                 {DocumentSelector = DocumentSelector.ForPattern("**/*.cake")});
             codeActionHandler2
-                .Handle(Arg.Any<CodeLensParams>(), Arg.Any<CancellationToken>())
-                .Returns(new CodeLensContainer());
+                .Handle(Arg.Any<CodeLensParams<ResolvedData>>(), Arg.Any<CancellationToken>())
+                .Returns(new CodeLensContainer<ResolvedData>());
 
             var collection =
                 new SharedHandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers())
                     {textDocumentSyncHandler, textDocumentSyncHandler2, codeActionHandler, codeActionHandler2};
             AutoSubstitute.Provide<IHandlerCollection>(collection);
             AutoSubstitute.Provide<IEnumerable<ILspHandlerDescriptor>>(collection);
+            AutoSubstitute.Provide<IHandlerMatcher>(AutoSubstitute.Resolve<TextDocumentMatcher>());
             var mediator = AutoSubstitute.Resolve<LspRequestRouter>();
 
             var id = Guid.NewGuid().ToString();
-            var @params = new CodeLensParams() {
+            var @params = new CodeLensParams<ResolvedData>() {
                 TextDocument = new TextDocumentIdentifier(new Uri("file:///c:/test/123.cs"))
             };
 
@@ -284,8 +288,8 @@ public async Task ShouldRouteToCorrect_Request_WithManyHandlers_CodeLensHandler(
 
             await mediator.RouteRequest(mediator.GetDescriptor(request), request, CancellationToken.None);
 
-            await codeActionHandler2.Received(0).Handle(Arg.Any<CodeLensParams>(), Arg.Any<CancellationToken>());
-            await codeActionHandler.Received(1).Handle(Arg.Any<CodeLensParams>(), Arg.Any<CancellationToken>());
+            await codeActionHandler2.Received(0).Handle(Arg.Any<CodeLensParams<ResolvedData>>(), Arg.Any<CancellationToken>());
+            await codeActionHandler.Received(1).Handle(Arg.Any<CodeLensParams<ResolvedData>>(), Arg.Any<CancellationToken>());
         }
 
         [Fact]
@@ -301,6 +305,7 @@ public async Task ShouldRouteTo_CorrectRequestWhenGivenNullParams()
                     {handler};
             AutoSubstitute.Provide<IHandlerCollection>(collection);
             AutoSubstitute.Provide<IEnumerable<ILspHandlerDescriptor>>(collection);
+            AutoSubstitute.Provide<IHandlerMatcher>(AutoSubstitute.Resolve<TextDocumentMatcher>());
             var mediator = AutoSubstitute.Resolve<LspRequestRouter>();
 
             var id = Guid.NewGuid().ToString();
diff --git a/test/Lsp.Tests/Matchers/ResolveCommandMatcherTests.cs b/test/Lsp.Tests/Matchers/ResolveCommandMatcherTests.cs
index 86abc8b4e..936fcc039 100644
--- a/test/Lsp.Tests/Matchers/ResolveCommandMatcherTests.cs
+++ b/test/Lsp.Tests/Matchers/ResolveCommandMatcherTests.cs
@@ -21,6 +21,8 @@ namespace Lsp.Tests.Matchers
 {
     public class ResolveCommandMatcherTests : AutoTestBase
     {
+        private readonly Guid TrueId = Guid.NewGuid();
+        private readonly Guid FalseId = Guid.NewGuid();
         public ResolveCommandMatcherTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
         {
         }
@@ -57,25 +59,25 @@ public void Should_Return_Empty_Descriptor()
         public void Should_Not_Throw_Given_Another_Descriptor()
         {
             // Given
-            var resolveHandler = Substitute.For<ICodeLensHandler>();
+            var resolveHandler = Substitute.For<ICodeLensHandler<ResolvedData>>();
             var handlerDescriptor = new LspHandlerDescriptor(
                 TextDocumentNames.CodeLens,
                 "Key",
                 resolveHandler,
                 resolveHandler.GetType(),
-                typeof(CodeLensParams),
+                typeof(CodeLensParams<ResolvedData>),
                 null,
                 null,
                 () => false,
                 null,
                 null,
                 () => { });
-            var handlerMatcher = new ResolveCommandPipeline<CodeLensParams, CodeLensContainer>(
+            var handlerMatcher = new ResolveCommandPipeline<CodeLensParams<ResolvedData>, CodeLensContainer<ResolvedData>>(
                 new RequestContext() {Descriptor = handlerDescriptor},
-                LoggerFactory.CreateLogger<ResolveCommandPipeline<CodeLensParams, CodeLensContainer>>());
+                LoggerFactory.CreateLogger<ResolveCommandPipeline<CodeLensParams<ResolvedData>, CodeLensContainer<ResolvedData>>>());
 
             // When
-            Func<Task> a = async () => await handlerMatcher.Handle(new CodeLensParams(), CancellationToken.None, () => Task.FromResult(new CodeLensContainer()));
+            Func<Task> a = async () => await handlerMatcher.Handle(new CodeLensParams<ResolvedData>(), CancellationToken.None, () => Task.FromResult(new CodeLensContainer<ResolvedData>()));
             a.Should().NotThrow();
         }
 
@@ -84,21 +86,21 @@ public void Should_Return_CodeLensResolve_Descriptor()
         {
             // Given
             var handlerMatcher = AutoSubstitute.Resolve<ResolveCommandMatcher>();
-            var resolveHandler = Substitute.For<ICodeLensResolveHandler>();
-            var resolveHandler2 = Substitute.For<ICodeLensResolveHandler>();
-            resolveHandler.CanResolve(Arg.Any<CodeLens>()).Returns(false);
-            resolveHandler2.CanResolve(Arg.Any<CodeLens>()).Returns(true);
+            var resolveHandler = Substitute.For<ICodeLensResolveHandler<ResolvedData>>();
+            var resolveHandler2 = Substitute.For<ICodeLensResolveHandler<ResolvedData>>();
+            resolveHandler.Id.Returns(FalseId);
+            resolveHandler2.Id.Returns(TrueId);
 
             // When
-            var result = handlerMatcher.FindHandler(new CodeLens() {
-                        Data = JToken.FromObject(new {handlerType = typeof(ICodeLensResolveHandler).FullName, data = new {a = 1}})
+            var result = handlerMatcher.FindHandler(new CodeLens<ResolvedData>() {
+                        Data = new ResolvedData() { handler = TrueId, Data = new Dictionary<string, JToken>() { ["a"] = 1 }}
                     },
                     new List<LspHandlerDescriptor> {
                         new LspHandlerDescriptor(TextDocumentNames.CodeLensResolve,
                             "Key",
                             resolveHandler,
                             resolveHandler.GetType(),
-                            typeof(CodeLens),
+                            typeof(CodeLens<ResolvedData>),
                             null,
                             null,
                             () => false,
@@ -108,8 +110,8 @@ public void Should_Return_CodeLensResolve_Descriptor()
                         new LspHandlerDescriptor(TextDocumentNames.CodeLensResolve,
                             "Key2",
                             resolveHandler2,
-                            typeof(ICodeLensResolveHandler),
-                            typeof(CodeLens),
+                            typeof(ICodeLensResolveHandler<ResolvedData>),
+                            typeof(CodeLens<ResolvedData>),
                             null,
                             null,
                             () => false,
@@ -129,49 +131,17 @@ public void Should_Handle_Null_Data()
         {
             // Given
             var handlerMatcher = AutoSubstitute.Resolve<ResolveCommandMatcher>();
-            var resolveHandler = Substitute.For<ICompletionResolveHandler>();
-            resolveHandler.CanResolve(Arg.Any<CompletionItem>()).Returns(true);
+            var resolveHandler = Substitute.For<ICompletionResolveHandler<ResolvedData>>();
+            resolveHandler.Id.Returns(TrueId);
 
             // When
-            var result = handlerMatcher.FindHandler(new CompletionItem() { },
+            var result = handlerMatcher.FindHandler(new CompletionItem<ResolvedData>() { },
                     new List<LspHandlerDescriptor> {
                         new LspHandlerDescriptor(TextDocumentNames.CompletionResolve,
                             "Key",
                             resolveHandler,
                             resolveHandler.GetType(),
-                            typeof(CompletionItem),
-                            null,
-                            null,
-                            () => false,
-                            null,
-                            null,
-                            () => { }),
-                    })
-                .ToArray();
-
-            // Then
-            result.Should().NotBeNullOrEmpty();
-            result.OfType<IHandlerDescriptor>().Should().Contain(x => x.Handler == resolveHandler);
-        }
-
-        [Fact]
-        public void Should_Handle_Simple_Json_Data()
-        {
-            // Given
-            var handlerMatcher = AutoSubstitute.Resolve<ResolveCommandMatcher>();
-            var resolveHandler = Substitute.For<ICompletionResolveHandler>();
-            resolveHandler.CanResolve(Arg.Any<CompletionItem>()).Returns(true);
-
-            // When
-            var result = handlerMatcher.FindHandler(new CompletionItem() {
-                        Data = new Uri("file:///c%3A/Users/mb/src/gh/Cake.Json/src/Cake.Json/Namespaces.cs")
-                    },
-                    new List<LspHandlerDescriptor> {
-                        new LspHandlerDescriptor(TextDocumentNames.CompletionResolve,
-                            "Key",
-                            resolveHandler,
-                            resolveHandler.GetType(),
-                            typeof(CompletionItem),
+                            typeof(CompletionItem<ResolvedData>),
                             null,
                             null,
                             () => false,
@@ -191,21 +161,21 @@ public void Should_Return_CompletionResolve_Descriptor()
         {
             // Given
             var handlerMatcher = AutoSubstitute.Resolve<ResolveCommandMatcher>();
-            var resolveHandler = Substitute.For<ICompletionResolveHandler>();
-            var resolveHandler2 = Substitute.For<ICompletionResolveHandler>();
-            resolveHandler.CanResolve(Arg.Any<CompletionItem>()).Returns(false);
-            resolveHandler2.CanResolve(Arg.Any<CompletionItem>()).Returns(true);
+            var resolveHandler = Substitute.For<ICompletionResolveHandler<ResolvedData>>();
+            var resolveHandler2 = Substitute.For<ICompletionResolveHandler<ResolvedData>>();
+            resolveHandler.Id.Returns(FalseId);
+            resolveHandler2.Id.Returns(TrueId);
 
             // When
-            var result = handlerMatcher.FindHandler(new CompletionItem() {
-                        Data = JToken.FromObject(new {handlerType = typeof(ICompletionResolveHandler).FullName, data = new {a = 1}})
+            var result = handlerMatcher.FindHandler(new CompletionItem<ResolvedData>() {
+                        Data = new ResolvedData() { handler = TrueId,  Data = new Dictionary<string, JToken>() { ["a"] = 1 }}
                     },
                     new List<LspHandlerDescriptor> {
                         new LspHandlerDescriptor(TextDocumentNames.CompletionResolve,
                             "Key",
                             resolveHandler,
                             resolveHandler.GetType(),
-                            typeof(CompletionItem),
+                            typeof(CompletionItem<ResolvedData>),
                             null,
                             null,
                             () => false,
@@ -215,60 +185,8 @@ public void Should_Return_CompletionResolve_Descriptor()
                         new LspHandlerDescriptor(TextDocumentNames.CompletionResolve,
                             "Key2",
                             resolveHandler2,
-                            typeof(ICompletionResolveHandler),
-                            typeof(CompletionItem),
-                            null,
-                            null,
-                            () => false,
-                            null,
-                            null,
-                            () => { }),
-                    })
-                .ToArray();
-
-            // Then
-            result.Should().NotBeNullOrEmpty();
-            result.OfType<IHandlerDescriptor>().Should().Contain(x => x.Handler == resolveHandler2);
-        }
-
-        [Fact]
-        public void Should_Deal_WithHandlers_That_Not_Also_Resolvers()
-        {
-            // Given
-            var handlerMatcher = AutoSubstitute.Resolve<ResolveCommandMatcher>();
-            var resolveHandler = Substitute.For<ICompletionResolveHandler>();
-            resolveHandler.CanResolve(Arg.Any<CompletionItem>()).Returns(false);
-            var resolveHandler2 = Substitute.For(new Type[] {
-                typeof(ICompletionHandler),
-                typeof(ICompletionResolveHandler)
-            }, new object[0]) as IJsonRpcHandler;
-            (resolveHandler2 as ICompletionResolveHandler).CanResolve(Arg.Any<CompletionItem>()).Returns(true);
-            (resolveHandler2 as ICompletionHandler).GetRegistrationOptions().Returns(
-                new CompletionRegistrationOptions() {
-                    DocumentSelector = DocumentSelector.ForLanguage("csharp")
-                });
-
-            // When
-            var result = handlerMatcher.FindHandler(new CompletionItem() {
-                        Data = new JObject()
-                    },
-                    new List<LspHandlerDescriptor> {
-                        new LspHandlerDescriptor(TextDocumentNames.CompletionResolve,
-                            "Key",
-                            resolveHandler,
-                            resolveHandler.GetType(),
-                            typeof(CompletionItem),
-                            null,
-                            null,
-                            () => false,
-                            null,
-                            null,
-                            () => { }),
-                        new LspHandlerDescriptor(TextDocumentNames.CompletionResolve,
-                            "Key2",
-                            resolveHandler2 as IJsonRpcHandler,
-                            typeof(ICompletionResolveHandler),
-                            typeof(CompletionItem),
+                            typeof(ICompletionResolveHandler<ResolvedData>),
+                            typeof(CompletionItem<ResolvedData>),
                             null,
                             null,
                             () => false,
@@ -283,96 +201,47 @@ public void Should_Deal_WithHandlers_That_Not_Also_Resolvers()
             result.OfType<IHandlerDescriptor>().Should().Contain(x => x.Handler == resolveHandler2);
         }
 
-        [Fact]
-        public void Should_Deal_WithHandlers_That_Not_Also_Resolvers2()
-        {
-            // Given
-            var handlerMatcher = AutoSubstitute.Resolve<ResolveCommandMatcher>();
-            var resolveHandler = Substitute.For<ICompletionResolveHandler>();
-            resolveHandler.CanResolve(Arg.Any<CompletionItem>()).Returns(true);
-            var resolveHandler2 = Substitute.For(new Type[] {
-                typeof(ICompletionHandler),
-                typeof(ICompletionResolveHandler)
-            }, new object[0]);
-            (resolveHandler2 as ICompletionResolveHandler).CanResolve(Arg.Any<CompletionItem>()).Returns(false);
-
-            // When
-            var result = handlerMatcher.FindHandler(new CompletionItem() {
-                        Data = new JObject()
-                    },
-                    new List<LspHandlerDescriptor> {
-                        new LspHandlerDescriptor(TextDocumentNames.CompletionResolve,
-                            "Key",
-                            resolveHandler,
-                            resolveHandler.GetType(),
-                            typeof(CompletionItem),
-                            null,
-                            null,
-                            () => false,
-                            null,
-                            null,
-                            () => { }),
-                        new LspHandlerDescriptor(TextDocumentNames.CompletionResolve,
-                            "Key2",
-                            resolveHandler2 as IJsonRpcHandler,
-                            typeof(ICompletionResolveHandler),
-                            typeof(CompletionItem),
-                            null,
-                            null,
-                            () => false,
-                            null,
-                            null,
-                            () => { }),
-                    })
-                .ToArray();
-
-            // Then
-            result.Should().NotBeNullOrEmpty();
-            result.OfType<IHandlerDescriptor>().Should().Contain(x => x.Handler == resolveHandler);
-        }
-
         [Fact]
         public async Task Should_Update_CompletionItems_With_HandlerType()
         {
             // Given
             var resolveHandler = Substitute.For(new Type[] {
-                typeof(ICompletionHandler),
-                typeof(ICompletionResolveHandler)
+                typeof(ICompletionHandler<ResolvedData>),
+                typeof(ICompletionResolveHandler<ResolvedData>)
             }, new object[0]);
-            (resolveHandler as ICompletionResolveHandler).CanResolve(Arg.Any<CompletionItem>()).Returns(true);
+            (resolveHandler as ICompletionResolveHandler<ResolvedData>).Id.Returns(TrueId);
             var descriptor = new LspHandlerDescriptor(
                 TextDocumentNames.Completion,
                 "Key",
                 resolveHandler as IJsonRpcHandler,
                 resolveHandler.GetType(),
-                typeof(CompletionParams),
+                typeof(CompletionParams<ResolvedData>),
                 null,
                 null,
                 () => false,
                 null,
                 null,
                 () => { });
-            var handlerMatcher = new ResolveCommandPipeline<CompletionParams, CompletionList>(
+            var handlerMatcher = new ResolveCommandPipeline<CompletionParams<ResolvedData>, CompletionList>(
                 new RequestContext() {Descriptor = descriptor},
-                Substitute.For<ILogger<ResolveCommandPipeline<CompletionParams, CompletionList>>>());
+                Substitute.For<ILogger<ResolveCommandPipeline<CompletionParams<ResolvedData>, CompletionList>>>());
 
-            var item = new CompletionItem() {
-                Data = JObject.FromObject(new {hello = "world"})
+            var item = new CompletionItem<ResolvedData>() {
+                Data = new ResolvedData() { Data = new Dictionary<string, JToken>() { ["hello"] = "world"}}
             };
             var list = new CompletionList(new[] {item});
 
-            (list is IEnumerable<ICanBeResolved>).Should().BeTrue();
+            (list is IEnumerable<ICanBeResolved<ResolvedData>>).Should().BeTrue();
 
             // When
-            var response = await handlerMatcher.Handle(new CompletionParams(), CancellationToken.None, () => Task.FromResult(list));
+            var response = await handlerMatcher.Handle(new CompletionParams<ResolvedData>(), CancellationToken.None, () => Task.FromResult(list));
 
             // Then
             response.Should().BeEquivalentTo(list);
             (response as CompletionList).Items.Should().Contain(item);
             var responseItem = (response as CompletionList).Items.First();
-            responseItem.Data[ResolveCommandMatcher.PrivateHandlerTypeName].Value<string>().Should().NotBeNullOrEmpty();
-            responseItem.Data[ResolveCommandMatcher.PrivateHandlerKey].Value<string>().Should().NotBeNullOrEmpty();
-            responseItem.Data["data"]["hello"].Value<string>().Should().Be("world");
+            responseItem.Data.handler.Should().Be(TrueId);
+            responseItem.Data.Data["hello"].Value<string>().Should().Be("world");
         }
 
         [Fact]
@@ -380,43 +249,42 @@ public async Task Should_Update_CodeLensContainer_With_HandlerType()
         {
             // Given
             var resolveHandler = Substitute.For(new Type[] {
-                typeof(ICodeLensHandler),
-                typeof(ICodeLensResolveHandler)
+                typeof(ICodeLensHandler<ResolvedData>),
+                typeof(ICodeLensResolveHandler<ResolvedData>)
             }, new object[0]);
-            (resolveHandler as ICodeLensResolveHandler).CanResolve(Arg.Any<CodeLens>()).Returns(true);
+            (resolveHandler as ICodeLensResolveHandler<ResolvedData>).Id.Returns(TrueId);
             var descriptor = new LspHandlerDescriptor(
                 TextDocumentNames.CodeLens,
                 "Key",
                 resolveHandler as IJsonRpcHandler,
                 resolveHandler.GetType(),
-                typeof(CodeLensParams),
+                typeof(CodeLensParams<ResolvedData>),
                 null,
                 null,
                 () => false,
                 null,
                 null,
                 () => { });
-            var handlerMatcher = new ResolveCommandPipeline<CodeLensParams, CodeLensContainer>(
+            var handlerMatcher = new ResolveCommandPipeline<CodeLensParams<ResolvedData>, CodeLensContainer<ResolvedData>>(
                 new RequestContext() {Descriptor = descriptor},
-                Substitute.For<ILogger<ResolveCommandPipeline<CodeLensParams, CodeLensContainer>>>());
+                Substitute.For<ILogger<ResolveCommandPipeline<CodeLensParams<ResolvedData>, CodeLensContainer<ResolvedData>>>>());
 
-            var item = new CodeLens() {
-                Data = JObject.FromObject(new {hello = "world"})
+            var item = new CodeLens<ResolvedData>() {
+                Data = new ResolvedData() { Data = new Dictionary<string, JToken>() { ["hello"] = "world"}}
             };
-            var list = new CodeLensContainer(new[] {item});
+            var list = new CodeLensContainer<ResolvedData>(new[] {item});
 
-            (list is IEnumerable<ICanBeResolved>).Should().BeTrue();
+            (list is IEnumerable<ICanBeResolved<ResolvedData>>).Should().BeTrue();
 
             // When
-            var response = await handlerMatcher.Handle(new CodeLensParams(), CancellationToken.None, () => Task.FromResult(list));
+            var response = await handlerMatcher.Handle(new CodeLensParams<ResolvedData>(), CancellationToken.None, () => Task.FromResult(list));
 
             // Then
             response.Should().BeEquivalentTo(list);
-            (response as CodeLensContainer).Should().Contain(item);
-            var responseItem = (response as CodeLensContainer).First();
-            responseItem.Data[ResolveCommandMatcher.PrivateHandlerTypeName].Value<string>().Should().NotBeNullOrEmpty();
-            responseItem.Data[ResolveCommandMatcher.PrivateHandlerKey].Value<string>().Should().NotBeNullOrEmpty();
-            responseItem.Data["data"]["hello"].Value<string>().Should().Be("world");
+            (response as CodeLensContainer<ResolvedData>).Should().Contain(item);
+            var responseItem = (response as CodeLensContainer<ResolvedData>).First();
+            responseItem.Data.handler.Should().Be(TrueId);
+            responseItem.Data.Data["hello"].Value<string>().Should().Be("world");
         }
 
         [Fact]
@@ -424,38 +292,38 @@ public async Task Should_Update_CodeLens_Removing_HandlerType()
         {
             // Given
             var resolveHandler = Substitute.For(new Type[] {
-                typeof(ICodeLensHandler),
-                typeof(ICodeLensResolveHandler)
+                typeof(ICodeLensHandler<ResolvedData>),
+                typeof(ICodeLensResolveHandler<ResolvedData>)
             }, new object[0]);
-            (resolveHandler as ICodeLensResolveHandler).CanResolve(Arg.Any<CodeLens>()).Returns(true);
+
+            (resolveHandler as ICodeLensResolveHandler<ResolvedData>).Id.Returns(TrueId);
             var descriptor = new LspHandlerDescriptor(
                 TextDocumentNames.CodeLensResolve,
                 "Key",
                 resolveHandler as IJsonRpcHandler,
                 resolveHandler.GetType(),
-                typeof(CodeLens),
+                typeof(CodeLens<ResolvedData>),
                 null,
                 null,
                 () => false,
                 null,
                 null,
                 () => { });
-            var handlerMatcher = new ResolveCommandPipeline<CodeLens, CodeLens>(
+            var handlerMatcher = new ResolveCommandPipeline<CodeLens<ResolvedData>, CodeLens<ResolvedData>>(
                 new RequestContext() {Descriptor = descriptor},
-                Substitute.For<ILogger<ResolveCommandPipeline<CodeLens, CodeLens>>>());
+                Substitute.For<ILogger<ResolveCommandPipeline<CodeLens<ResolvedData>, CodeLens<ResolvedData>>>>());
 
-            var item = new CodeLens() {
-                Data = JObject.FromObject(new {data = new {hello = "world"}})
+            var item = new CodeLens<ResolvedData>() {
+                Data = new ResolvedData() { Data = new Dictionary<string, JToken>() { ["hello"] = "world"}}
             };
-            item.Data[ResolveCommandMatcher.PrivateHandlerTypeName] = resolveHandler.GetType().FullName;
+            item.Data.handler = TrueId;
 
             // When
             var response = await handlerMatcher.Handle(item, CancellationToken.None, () => Task.FromResult(item));
 
             // Then
             response.Should().BeEquivalentTo(item);
-            item.Data?[ResolveCommandMatcher.PrivateHandlerTypeName].Should().BeNull();
-            item.Data["hello"].Value<string>().Should().Be("world");
+            item.Data.Data["hello"].Value<string>().Should().Be("world");
         }
     }
 }
diff --git a/test/Lsp.Tests/Matchers/TextDocumentMatcherTests.cs b/test/Lsp.Tests/Matchers/TextDocumentMatcherTests.cs
index 8f765bfd6..a6d67ef87 100644
--- a/test/Lsp.Tests/Matchers/TextDocumentMatcherTests.cs
+++ b/test/Lsp.Tests/Matchers/TextDocumentMatcherTests.cs
@@ -194,14 +194,14 @@ public void Should_Return_Code_Lens_Descriptor()
             AutoSubstitute.Provide<IEnumerable<ILspHandlerDescriptor>>(collection);
             var handlerMatcher = AutoSubstitute.Resolve<TextDocumentMatcher>();
 
-            var codeLensHandler = Substitute.For(new Type[] { typeof(ICodeLensHandler), typeof(ICodeLensResolveHandler) }, new object[0]) as ICodeLensHandler;
+            var codeLensHandler = Substitute.For(new Type[] { typeof(ICodeLensHandler<ResolvedData>), typeof(ICodeLensResolveHandler<ResolvedData>) }, new object[0]) as ICodeLensHandler<ResolvedData>;
             codeLensHandler.GetRegistrationOptions()
                 .Returns(new CodeLensRegistrationOptions()
                 {
                     DocumentSelector = new DocumentSelector(new DocumentFilter { Pattern = "**/*.cs" })
                 });
 
-            var codeLensHandler2 = Substitute.For(new Type[] { typeof(ICodeLensHandler), typeof(ICodeLensResolveHandler) }, new object[0]) as ICodeLensHandler;
+            var codeLensHandler2 = Substitute.For(new Type[] { typeof(ICodeLensHandler<ResolvedData>), typeof(ICodeLensResolveHandler<ResolvedData>) }, new object[0]) as ICodeLensHandler<ResolvedData>;
             codeLensHandler2.GetRegistrationOptions()
                 .Returns(new CodeLensRegistrationOptions()
                 {
@@ -210,7 +210,7 @@ public void Should_Return_Code_Lens_Descriptor()
             collection.Add(codeLensHandler, codeLensHandler2);
 
             // When
-            var result = handlerMatcher.FindHandler(new CodeLensParams()
+            var result = handlerMatcher.FindHandler(new CodeLensParams<ResolvedData>()
             {
                 TextDocument = new VersionedTextDocumentIdentifier { Uri = new Uri("file:///abc/123/d.cs"), Version = 1 }
             },
diff --git a/test/Lsp.Tests/Models/CodeLensParamsTests.cs b/test/Lsp.Tests/Models/CodeLensParamsTests.cs
index fe1588375..985779266 100644
--- a/test/Lsp.Tests/Models/CodeLensParamsTests.cs
+++ b/test/Lsp.Tests/Models/CodeLensParamsTests.cs
@@ -13,21 +13,21 @@ public class CodeLensParamsTests
         [Theory, JsonFixture]
         public void SimpleTest(string expected)
         {
-            var model = new CodeLensParams() {
+            var model = new CodeLensParams<ResolvedData>() {
                 TextDocument = new TextDocumentIdentifier(new Uri("file:///abc/123/d.cs")),
             };
             var result = Fixture.SerializeObject(model);
 
             result.Should().Be(expected);
 
-            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<CodeLensParams>(expected);
+            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<CodeLensParams<ResolvedData>>(expected);
             deresult.Should().BeEquivalentTo(model);
         }
 
         [Theory, JsonFixture]
         public void NonStandardCharactersTest(string expected)
         {
-            var model = new CodeLensParams() {
+            var model = new CodeLensParams<ResolvedData>() {
                 // UNC path with Chinese character for tree.
                 TextDocument = new TextDocumentIdentifier(DocumentUri.FromFileSystemPath("\\\\abc\\123\\树.cs")),
             };
@@ -35,7 +35,7 @@ public void NonStandardCharactersTest(string expected)
 
             result.Should().Be(expected);
 
-            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<CodeLensParams>(expected);
+            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<CodeLensParams<ResolvedData>>(expected);
             deresult.Should().BeEquivalentTo(model);
         }
     }
diff --git a/test/Lsp.Tests/Models/CodeLensTests.cs b/test/Lsp.Tests/Models/CodeLensTests.cs
index 844252cd0..581d9df65 100644
--- a/test/Lsp.Tests/Models/CodeLensTests.cs
+++ b/test/Lsp.Tests/Models/CodeLensTests.cs
@@ -14,16 +14,18 @@ public class CodeLensTests
         [Theory, JsonFixture]
         public void SimpleTest(string expected)
         {
-            var model = new CodeLens() {
+            var model = new CodeLens<ResolvedData>() {
                 Command = new Command() {
                     Arguments = new JArray { 1, "2", true },
                     Name = "abc",
                     Title = "Cool story bro"
                 },
-                Data = JObject.FromObject(new Dictionary<string, object>()
-                {
-                    { "somethingCool" , 1 }
-                }),
+                Data = new ResolvedData {
+                    Data = new Dictionary<string, JToken>()
+                    {
+                        { "somethingCool" , 1 }
+                    },
+                },
                 Range = new Range(new Position(1, 2), new Position(2, 3)),
             };
             var result = Fixture.SerializeObject(model);
@@ -31,7 +33,7 @@ public void SimpleTest(string expected)
             result.Should().Be(expected);
 
             // TODO: Come back and fix this...
-            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<CodeLens>(expected);
+            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<CodeLens<ResolvedData>>(expected);
             deresult.Should().BeEquivalentTo(model);
         }
     }
diff --git a/test/Lsp.Tests/Models/CompletionItemTests.cs b/test/Lsp.Tests/Models/CompletionItemTests.cs
index 7d56a8424..969862027 100644
--- a/test/Lsp.Tests/Models/CompletionItemTests.cs
+++ b/test/Lsp.Tests/Models/CompletionItemTests.cs
@@ -11,7 +11,7 @@ public class CompletionItemTests
         [Theory, JsonFixture]
         public void SimpleTest(string expected)
         {
-            var model = new CompletionItem()
+            var model = new CompletionItem<ResolvedData>()
             {
                 Kind = CompletionItemKind.Text,
                 CommitCharacters = new[] { ";", "/", "." },
@@ -25,7 +25,7 @@ public void SimpleTest(string expected)
 
             result.Should().Be(expected);
 
-            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<CompletionItem>(expected);
+            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<CompletionItem<ResolvedData>>(expected);
             deresult.Should().BeEquivalentTo(model);
         }
     }
diff --git a/test/Lsp.Tests/Models/CompletionListTests.cs b/test/Lsp.Tests/Models/CompletionListTests.cs
index 26646d794..0de0bd6f1 100644
--- a/test/Lsp.Tests/Models/CompletionListTests.cs
+++ b/test/Lsp.Tests/Models/CompletionListTests.cs
@@ -12,7 +12,7 @@ public class CompletionListTests
         [Theory, JsonFixture]
         public void SimpleTest(string expected)
         {
-            var model = new CompletionList(new List<CompletionItem>() { new CompletionItem()
+            var model = new CompletionList(new List<CompletionItem<ResolvedData>>() { new CompletionItem<ResolvedData>()
             {
                 Kind = CompletionItemKind.Class,
                 Detail = "details"
@@ -28,8 +28,8 @@ public void SimpleTest(string expected)
         [Theory, JsonFixture]
         public void ComplexTest(string expected)
         {
-            var model = new CompletionList(new List<CompletionItem>() {
-                new CompletionItem()
+            var model = new CompletionList(new List<CompletionItem<ResolvedData>>() {
+                new CompletionItem<ResolvedData>()
             {
                 Kind = CompletionItemKind.Class,
                 Detail = "details"
diff --git a/test/Lsp.Tests/Models/DocumentLinkParamsTests.cs b/test/Lsp.Tests/Models/DocumentLinkParamsTests.cs
index aac1dd948..95ca85260 100644
--- a/test/Lsp.Tests/Models/DocumentLinkParamsTests.cs
+++ b/test/Lsp.Tests/Models/DocumentLinkParamsTests.cs
@@ -12,14 +12,14 @@ public class DocumentLinkParamsTests
         [Theory, JsonFixture]
         public void SimpleTest(string expected)
         {
-            var model = new DocumentLinkParams() {
+            var model = new DocumentLinkParams<ResolvedData>() {
                 TextDocument = new TextDocumentIdentifier(new Uri("file:///abc/123.cs"))
             };
             var result = Fixture.SerializeObject(model);
 
             result.Should().Be(expected);
 
-            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<DocumentLinkParams>(expected);
+            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<DocumentLinkParams<ResolvedData>>(expected);
             deresult.Should().BeEquivalentTo(model);
         }
     }
diff --git a/test/Lsp.Tests/Models/DocumentLinkTests.cs b/test/Lsp.Tests/Models/DocumentLinkTests.cs
index 09dd8f83c..fd27c457c 100644
--- a/test/Lsp.Tests/Models/DocumentLinkTests.cs
+++ b/test/Lsp.Tests/Models/DocumentLinkTests.cs
@@ -13,7 +13,7 @@ public class DocumentLinkTests
         [Theory, JsonFixture]
         public void SimpleTest(string expected)
         {
-            var model = new DocumentLink() {
+            var model = new DocumentLink<ResolvedData>() {
                 Range = new Range(new Position(1, 2), new Position(3, 4)),
                 Target = new Uri("file:///abc/123.cs")
             };
@@ -21,7 +21,7 @@ public void SimpleTest(string expected)
 
             result.Should().Be(expected);
 
-            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<DocumentLink>(expected);
+            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<DocumentLink<ResolvedData>>(expected);
             deresult.Should().BeEquivalentTo(model);
         }
     }
diff --git a/test/Lsp.Tests/RequestProcessIdentifierTests.cs b/test/Lsp.Tests/RequestProcessIdentifierTests.cs
index 14dc4121d..91bab7cf2 100644
--- a/test/Lsp.Tests/RequestProcessIdentifierTests.cs
+++ b/test/Lsp.Tests/RequestProcessIdentifierTests.cs
@@ -4,6 +4,7 @@
 using OmniSharp.Extensions.JsonRpc;
 using OmniSharp.Extensions.LanguageServer.Protocol.Document;
 using OmniSharp.Extensions.LanguageServer.Protocol.General;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 using OmniSharp.Extensions.LanguageServer.Protocol.Workspace;
 using OmniSharp.Extensions.LanguageServer.Shared;
 using Xunit;
@@ -33,13 +34,13 @@ public void ShouldIdentifyAs_Default()
 
         [Theory]
         [InlineData(typeof(ICodeActionHandler))]
-        [InlineData(typeof(ICodeLensHandler))]
-        [InlineData(typeof(ICodeLensResolveHandler))]
+        [InlineData(typeof(ICodeLensHandler<ResolvedData>))]
+        [InlineData(typeof(ICodeLensResolveHandler<ResolvedData>))]
         [InlineData(typeof(IDefinitionHandler))]
         [InlineData(typeof(IDidCloseTextDocumentHandler))]
         [InlineData(typeof(IDocumentHighlightHandler))]
-        [InlineData(typeof(IDocumentLinkHandler))]
-        [InlineData(typeof(IDocumentLinkResolveHandler))]
+        [InlineData(typeof(IDocumentLinkHandler<ResolvedData>))]
+        [InlineData(typeof(IDocumentLinkResolveHandler<ResolvedData>))]
         [InlineData(typeof(IDocumentSymbolHandler))]
         [InlineData(typeof(IWorkspaceSymbolsHandler))]
         [InlineData(typeof(IWillSaveTextDocumentHandler))]
diff --git a/test/Lsp.Tests/TextDocumentSyncHandlerExtensions.cs b/test/Lsp.Tests/TextDocumentSyncHandlerExtensions.cs
index d1e4acf4e..989ac15cd 100644
--- a/test/Lsp.Tests/TextDocumentSyncHandlerExtensions.cs
+++ b/test/Lsp.Tests/TextDocumentSyncHandlerExtensions.cs
@@ -19,11 +19,11 @@ public static ITextDocumentSyncHandler With(this ITextDocumentSyncHandler handle
             ((IDidCloseTextDocumentHandler)handler).GetRegistrationOptions().Returns(new TextDocumentRegistrationOptions() { DocumentSelector = documentSelector });
             ((IDidSaveTextDocumentHandler)handler).GetRegistrationOptions().Returns(new TextDocumentSaveRegistrationOptions() { DocumentSelector = documentSelector });
             ((ITextDocumentIdentifier) handler).GetTextDocumentAttributes(Arg.Any<DocumentUri>())
-                .Returns((info) => new TextDocumentAttributes(info.Arg<DocumentUri>(), language));
+                .Returns((info) => new  [] { new TextDocumentAttributes(info.Arg<DocumentUri>(), language) });
 
             handler
                 .GetTextDocumentAttributes(Arg.Is<DocumentUri>(x => documentSelector.IsMatch(new TextDocumentAttributes(x, language))))
-                .Returns(c => new TextDocumentAttributes(c.Arg<DocumentUri>(), language));
+                .Returns(c => new  [] { new TextDocumentAttributes(c.Arg<DocumentUri>(), language) });
 
             return handler;
         }