anchor.diff:      SessId, _Sock, _Transport) ->
       sequencer:route_message(Msg, SessId);
   preroute_message(#client_message{message_stream = undefined} = Msg,
  -    _SessId, Sock, Transport) ->
  -    router:route_message(Msg, Sock, Transport);
  +    SessId, Sock, Transport) ->
  +    IsProviderSession = session_manager:is_provider_session_id(SessId),
  +    router:route_message(Msg, Sock, Transport, IsProviderSession);
   preroute_message(#client_message{message_body = #subscription{}} = Msg,
       SessId, _Sock, _Transport) ->
       case session_manager:is_provider_session_id(SessId) of
  
positive.code: %% @private
  %% @doc
  %% Route message to adequate worker, asynchronously wait for answer
  %% repack it into server_message and send to the client
  %% @end
  %%--------------------------------------------------------------------
  -spec route_and_send_answer(#client_message{}, Sock :: ssl:socket() | undefined,
      Transport :: module() | undefined) ->
      ok | {ok, #server_message{}} | {error, term()}.
  route_and_send_answer(Msg = #client_message{
      session_id = OriginSessId,
      message_id = MsgId,
      message_body = FlushMsg = #flush_events{}
  }, _Sock, _Transport) ->
      event:flush(FlushMsg#flush_events{notify =
          fun(Result) ->
              % Spawn because send can wait and block event_stream
              spawn(fun() ->
                  communicator:send(Result#server_message{message_id = MsgId}, OriginSessId)
              end)
          end
      }, effective_session_id(Msg)),
      ok;
  route_and_send_answer(#client_message{
      message_id = Id,
      message_body = #ping{data = Data}
  }, _Sock, _Transport) ->
      {ok, #server_message{message_id = Id, message_body = #pong{data = Data}}};
  route_and_send_answer(#client_message{
      message_id = Id,
      message_body = #get_protocol_version{}
  }, _Sock, _Transport) ->
      {ok, #server_message{message_id = Id, message_body = #protocol_version{}}};
  route_and_send_answer(Msg = #client_message{
      message_id = Id,
      message_body = #get_configuration{}
  
negative.code: %% @end
  %%--------------------------------------------------------------------
  -spec route_message(Msg :: #client_message{} | #server_message{},
      Sock :: ssl:socket() | undefined, Transport :: module() | undefined,
      IsProviderSession :: boolean()) ->
      ok | {ok, #server_message{}} | {error, term()}.
  route_message(Msg = #client_message{message_id = undefined}, _Sock, _Transport,
      _IsProviderSession) ->
      route_and_ignore_answer(Msg);
  route_message(Msg = #client_message{message_id = #message_id{
      issuer = Issuer,
      recipient = Recipient
  }}, Sock, Transport, IsProviderSession) ->
      case oneprovider:is_self(Issuer) of
          true when Recipient =:= undefined ->
              route_and_ignore_answer(Msg);
  