Strictly typed dynamic proxy to call dynamic object GitHub and NuGet

I would like to use DynamicObject derived types to execute  REST API/NodeJS module calls. It would also help to capture API shape in a strictly typed manner, so here comes an interface proxy which hides low level machinery allowing to do tricks like this:

[TestMethod]
public void Call()
{
    dynamic c = new ExpandoObject();
    c.Add = (Func&lt;int, int, int&gt;)((a, b) =&gt; a + b);

    ICalculator proxy = Proxy.Create&lt;ICalculator&gt;(c);
    Assert.AreEqual(3, proxy.Add(1, 2));
}

public interface ICalculator
{
   int Add(int a, int b);
}


Library code is:

using Castle.DynamicProxy;
using Dynamitey;
using System;

namespace Dynoproxy
{
    public static class Proxy
    {
        public static T Create&lt;T&gt;(this object source) where T : class
        {
            var proxyGenerator = new ProxyGenerator();
            return proxyGenerator.CreateInterfaceProxyWithoutTarget&lt;T&gt;(
                ProxyGenerationOptions.Default,
                new Interceptor(source));
        }

        class Interceptor : IInterceptor
        {
            public Interceptor(object target) =&gt; Target = target;
            object Target { get; }
            public void Intercept(IInvocation invocation) =&gt;
                invocation.ReturnValue = Dynamic.InvokeMember(
                    Target, invocation.Method.Name, invocation.Arguments);
        }
    }
}
It would be very useful to see the associated MethodInfo instance while implementing source in the situation like this:

interface IMyWebApi
{
    [Description("GET orders/{0}")]
    Order GetOrder(int id); 
}

IWebApi api = Proxy.Create&lt;IMyWebApi&gt;(new RestApi("http://example.com/api"));
Order order = api.GetOrder(33);


So I made the proxy injecting it when DescriptionAttribute is provided:

[TestMethod]
public void Call()
{
    dynamic c = new ExpandoObject();
    c.Add = (Func&lt;int, int, int&gt;)((a, b) =&gt; a + b);
    c.Divide = (Func&lt;MethodInfo, int, int, int&gt;)((mi, a, b) =&gt; a / b);

    ICalculator proxy = Proxy.Create&lt;ICalculator&gt;(c);
    Assert.AreEqual(3, proxy.Add(1, 2));
    Assert.AreEqual(2, proxy.Divide(4, 2));
}

public interface ICalculator
{
    int Add(int a, int b);

    [Description]
    int Divide(int a, int b);
}


It should provide access to all interface method attributes and return types.

Updated Interceptor looks like this now:

class Interceptor : IInterceptor
{
    public Interceptor(object target) =&gt; Target = target;
    object Target { get; }
    public void Intercept(IInvocation invocation) =&gt;
        invocation.ReturnValue = Dynamic.InvokeMember(
            Target,
            invocation.Method.Name,
            invocation.Method.IsDefined(typeof(DescriptionAttribute)) 
                ? invocation.Arguments.Prepend(invocation.Method).ToArray()
                : invocation.Arguments);
}