anchor.diff:      {error, no_connection_info}.
   
   
  -create_command_list_and_update_state(Cmd, UserInfo, ServiceInfo,
  -                                     {ok, Connection}, State)
  +create_command_and_update_state(Cmd, UserInfo, ServiceInfo,
  +                                {ok, Connection}, State)
     when is_binary(Cmd) ->
       #state{
          action = Action,
  
positive.code:     {ok, State}.
  
  
  prepare_action(State) ->
      #state{service_info = ServiceInfo,
             user_info = UserInfo
  
negative.code:               Params::any(), Queue::binary(), pid()) -> {ok, map(), list()} |
                                         {error, any(), list()} | {error, atom()}.
  request(ServiceId, UserInfo, Params, Queue, Pid) ->
      Config = #{
        action => request,
        service_id => ServiceId,
        user_info => UserInfo,
        params => Params,
        queue => Queue,
        pid => Pid},
      request_action(Config).
  
  -spec revoke(ServiceId :: binary(), UserInfo :: map(),
               CredState::any(), Queue::binary(), pid()) -> {ok, map(), list()} |
                                           {error, any(), list()}|{error, atom()}.
  revoke(ServiceId, UserInfo, CredState, Queue, Pid) ->
      Config = #{
        action => revoke,
        service_id => ServiceId,
        user_info => UserInfo,
        cred_state => CredState,
        queue => Queue,
        pid => Pid},
      request_action(Config).
  
  -spec get_params(ServiceId ::any(), Pid::pid()) -> {ok, map()} |
                                                     {error, atom(), list()} |
                                                     {error, atom()}.
  get_params(ServiceId, Pid) ->
      Config = #{
        action => parameter,
        service_id => ServiceId,
        pid => Pid},
      request_action(Config).
  
  
  request_action(#{action := Action, service_id := ServiceId,
                   pid := Pid} = ConfigIn) ->
      try
          {ok, ServiceInfo} = watts_service:get_info(ServiceId),
          Timeout = maps:get(plugin_timeout, ServiceInfo, infinity),
          Config = maps:put(service_info, ServiceInfo, ConfigIn),
          gen_server:call(Pid, {request_action,  Config}, Timeout)
      catch
          exit:{timeout, _} ->
              timeout_result(Action)
      end.
  
  
  