   executing the method,
   """
   def call(pid, method, params, context) do
-    case __call(pid, method, params, context) do
+    case __call(pid, %RPC.Message{ method: method, params: params, context: context}) do
       {:ok, ret} -> ret
       {:error, :unknown_method} -> raise RPC.UnknownMethod, method: method
+      nil -> raise RPC.UnknownMethod, method: method
       {:error, e} -> raise e
       #other -> Logger.error(inspect other)
     end
   end
 
   # same as call, but return {:ok, ret} or {:error, err}, easier to compose
-  defp __call(pid, method, params, context) do
-    #Logger.debug("Fast call #{method}")
+  defp __call(pid, msg) do
     st = Agent.get pid, &(&1)
-    case Map.get st.methods, method do
+    case Map.get st.methods, msg.method do
       {f, options} ->
+        Logger.debug("Fast call #{msg.method} #{inspect pid}")
         if Keyword.get(options, :context, false) do
-          {:ok, f.(params, context)}
+          {:ok, f.(msg.params, msg.context)}
         else
-          {:ok, f.(params)}
+          {:ok, f.(msg.params)}
         end
       nil ->
         Enum.reduce_while st.mc, nil, fn mc, _acc ->
-          case __call(mc, method, params, context) do
+          ret = case mc do
+            mc when is_pid(mc) ->
+              Logger.debug("Slow call PID #{msg.method} #{inspect mc}")
+              __call(mc, msg)
+            f when is_function(f) ->
+              Logger.debug("Slow call f #{msg.method} #{inspect mc}")
+              f.(msg)
+          end
+          Logger.debug("Result #{inspect ret}")
+          case ret do
             {:ok, ret} -> {:halt, {:ok, ret}}
             {:error, :unknown_method} -> {:cont, nil}
+            :nok -> {:cont, nil}
+            :empty -> {:cont, nil}
+
             {:error, other} -> {:halt, {:error, other}}
-            #other -> Logger.error(inspect other)
           end
         end
     end

  If the method does not exists, returns :nok, if it does, returns :ok.

  Callback is a function that can receive {:ok, value} or {:error, %Exception{...}}

  Possible errors:
   * :unknown_method


  This another caller can be even shared between several method callers.

  Method callers are optimized callers, but a single function can be passed and
  it will be called with an %RPC.Message. If it returns {:ok, res} or
  {:error, error} its processed, :empty or :nok tries next callers.

  ## Example:

  I will create three method callers, so that a calls, and b too. Method can
  be shadowed at parent too.
