 
   def get_features(_options), do: {:caller, %{}}
 
-  def handle_message(%Message{type: :result} = result, peer, state) do
-    :ok = Peer.send_to_owner(peer, result)
-    {:ok, state}
+  def init(_peer, _options) do
+    {:ok, %__MODULE__{}}
+  end
+
+  @doc """
+  Handle `RESULT` messages.
+  """
+  def handle_message(%Message{type: :result,
+                              args: [request | _]} = result,
+                     peer, state) do
+    case Dict.pop(state.call_requests, request) do
+      {nil, _} ->
+        {:error, :no_call}
+      {pid, call_requests} ->
+        :ok = Peer.notify(pid, result)
+        {:ok, %{state | call_requests: call_requests}}
+    end
   end
 
   def handle_message(message, peer, state) do
     super(message, peer, state)
+  end
+
+  @doc """
+  The `handle_call` callback is used to send `CALL` messages.
+  """
+  def handle_call({:send, %Message{type: :call,
+                                   args: [request | _]} = message},
+                  {pid, _}, peer, state) do
+    :ok = Peer.send_message(peer, message)
+    call_requests = Dict.put_new(state.call_requests, request, pid)
+    {:ok, :ok, %{state | call_requests: call_requests}}
   end
 
   # Private Functions


  ## Options

  TODO
  """
  @spec call(pid, Message.wamp_uri, Keyword.t) :: {:ok, integer}
  def call(peer, procedure, options \\ []) do

  alias Spell.Message
  alias Spell.Peer

  defstruct [call_requests: HashDict.new()]

  @doc """
  Using `peer` asynchronously call `procedure` with `options`.
