Should Service A be dependent on service B or abstract the logic in a fat client - oop

Question

This is a system design/architecture question around setting up 2 TIER 0 services - Service A & Service B.
Service A depends on service B for additional information to return a more accurate response. I have 2 options here:
Service A internally calls Service B for this additional information. So clients of service A use a thin client library.
Clients of service A provide this additional information in the request to Service A. Maybe by hiding the logic to call Service B before calling Service A in the client.
Features of Option 1
Client library for Service A is a thin client with no logic.
Failure and latency of Service A are tied to service B.
Sending a request to Service A is a one-stop solution for the entire request.
Features of Option 2
Client library for Service A has to have some logic to get all the request arguments from Service B before sending the request to Service A.
Failures of Service A and Service B are independent and easier to reason about.
Service A is no longer a one-stop solution for a detailed, accurate response.
Sample API for service A:
// Returns true if any of the user in the list can perform the |action| on the |resource|.
isAllowed(User[], Action, Resource): Boolean
Sample API for service B:
// Returns all the relatives for the provided list of users
getRelatives(User[]): User[]
Option 1
Now should the service A look like:
// Client for Service A:
class clientA {
isAllowed(User[] users, Action action, Resource res): Boolean = {
return ServiceA.isAllowed(users, action, res)
}
}
// Service A implementation
class ServiceA {
isAllowed(User[] users, Action action, Resource res): Boolean = {
allUsers = ServiceB.getRelatives(users) + users
return allUsers.any(user => res.canPerform(action, user))
}
Option 2
or should it look like:
// Client for Service A:
class clientA {
isAllowed(User[] users, Action action, Resource res): Boolean = {
allUsers = ServiceB.getRelatives(users) + users
return ServiceA.isAllowed(allUsers, action, res)
}
}
// Service A implementation
class ServiceA {
isAllowed(User[] users, Action action, Resource res): Boolean = {
allUsers = ServiceB.getRelatives(users) + users
return allUsers.any(user => res.canPerform(action, user))
}
}
Question:
What are the benefits of one approach over the other?
When should one pick one option over the other?