Function execute

packages/plugins/mcp/src/sdk/connection.ts:234–308

(url, init)

  httpClientLayer: Layer.Layer<HttpClient.HttpClient>,
): FetchLike => {
  const execute: FetchLike = async (url, init) => {
    const headers = headersFrom(init?.headers);
    const requestWithoutBody = HttpClientRequest.make(httpMethodFrom(init?.method))(url, {
      headers: recordFromHeaders(headers),
    });
    const request = await applyBody(requestWithoutBody, headers, init?.body);
    const effect = Effect.gen(function* () {
      const client = yield* HttpClient.HttpClient;
      const response = yield* client.execute(request);
      const responseHeaders = new Headers();
      for (const [key, value] of Object.entries(response.headers)) {
        if (value !== undefined) responseHeaders.set(key, value);
      }
      // Abort must reach the body, not just the pending request: this stream
      // fiber outlives the `runPromise` below, so without this streamable
      // http's SSE `GET` stays in flight after `close()`. Interrupted at the
      // source because the SDK holds a locked reader on that same stream,
      // which rules out cancelling the ReadableStream.
      const stream =
        init?.signal == null
          ? response.stream
          : Stream.interruptWhen(response.stream, awaitAbort(init.signal));
      const body =
        response.status === 204 || response.status === 205 || response.status === 304
          ? null
          : Stream.toReadableStream(stream);
      return new Response(body, {
        status: response.status,
        headers: responseHeaders,
      });
    }).pipe(Effect.mapError(normalizeHttpClientFailure), Effect.provide(httpClientLayer));
    // A 403 carrying an RFC 6750 insufficient_scope challenge is intercepted
    // HERE, below the SDK: with an authProvider the SDK would consume the
    // challenge and re-run auth ("upscoping"), which our static-token
    // provider can only answer by demanding reauthorization — misclassifying
    // an unfixable scope shortfall as oauth_reauth_required. Thrown as the
    // tagged error from the fetch adapter (a true runtime edge: the SDK
    // consumes promise rejections) so it reaches the invoke/connect catch
    // sites verbatim.
    const promise = Effect.runPromise(effect).then((response) => {
      if (response.status === 403) {
        const challenge = response.headers.get("www-authenticate");
        if (
          challenge !== null &&
          detectInsufficientScope({ headers: { "www-authenticate": challenge } }) !== null
        ) {
          // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: Fetch-compatible adapter can only signal through a rejected promise
          throw new McpInsufficientScopeError({
            message:
              "MCP server rejected the call: the OAuth grant does not cover the required scope",
          });
        }
      }
      return response;
    });
    // Mark the request promise observed (a no-op handler on the ORIGINAL
    // promise; callers still see the rejection). The MCP SDK fires some
    // requests without a rejection handler — a cancellation notification