Repository navigation
Scope challenge raised from inside a running tool handler #2957
Description
Follow-up to #1151. The first half shipped in 2.1.0 (#1624): scopeChallenge on a tool registration answers with a 403 scope challenge before the handler runs.
Still open is the second half: a handler that only learns mid-execution that more scopes are needed (for example because the backend says so) and wants to turn that into a scope challenge instead of a failed tool call, something like throw new ScopeChallengeError(['repo:read']).
Open question from the original thread: whether this is possible at all once the response has started.
Activity
Ben-Home commentedon Oct 5, 2026
buptliuhs commentedon Nov 11, 2026
A related case that this design could cover with the same mechanism: 401
invalid_tokeninstead of 403insufficient_scope.Servers that proxy an upstream API with delegated OAuth (the MCP access token maps to an upstream refresh token stored server-side) can learn mid-call that the user's upstream authorization is gone — the upstream provider revoked the refresh token (for example, a per-user connection cap evicting the oldest connection). The MCP access token is still valid, but the connection is unusable until the user re-authorizes. It's the same shape as this issue: the handler only finds out from its backend, and a failed tool call (
200+isError) is the wrong answer, because the client doesn't start its re-auth flow until a later request.So a request: whatever ships here (
ScopeChallengeErroror similar), allow it to carry a 401invalid_tokenchallenge as well as a 403insufficient_scopeone — e.g. a generalAuthChallengeErrorwith{ status: 401 | 403, error, errorDescription?, scopes? }— answered through the sameWWW-Authenticate+resource_metadatapath asrequireBearerAuth.Data point on the "after the response has started" question: we handle this today with a wrapper around the handler's fetch face (
FetchLikeMcpHandler) that holds the completeResponsefortools/calland swaps in the 401 when the tool recorded a lost upstream link. It works on both protocol eras because our server is stateless and never sends anything mid-request, so the response is never committed early. It also confirms the retry-safety point above: we only swap when the upstream call was rejected before processing (an upstream 401), so no side effects happened and the client can safely retry after re-authorizing.