Best approach on handling function that returns either a promise or just synchronous code
You really don't want a function sometimes returning a promise and sometimes returning a value.  That just makes it difficult for the caller.  Instead, if you sometimes have a promise to return, then you should always return a promise.  

function isActive(){
  if(condition){
    return API.someFunction().then(function(response){
      return response;
    });
  }
  return Promise.resolve(active);
}


Then, your caller can just know that it always returns a promise and they can code accordingly.  When you have complexity like this, it's better to encapsulate it in the function itself rather than make every single caller deal with it.

So, the caller can then always and consistently just do:

isActive().then(...).catch(...);




Also, if you actually have this in your real code:

   .then(function(response){
      return response;
    });


then, you can remove that entirely and just use this as it generates the exact same result, but is less code:

function isActive(){
  if(condition){
    return API.someFunction();
  }
  return Promise.resolve(active);
}


Both examples return a promise that resolves to response.  One is obviously a lot simpler than the other.