Function execute

packages/plugins/mcp/src/sdk/connection.ts:299–407

(url, init)

  staticOAuthBearer: boolean,
): 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));
    // Executor resolves and refreshes OAuth credentials before constructing
    // this transport. If that stored bearer is rejected, the MCP SDK cannot
    // complete its interactive fallback in a catalog refresh and would perform
    // avoidable DCR first. Stop at the authenticated HTTP boundary instead.
    // 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(async (response) => {
      let settled = response;
      if (staticOAuthBearer && settled.status === 401) {
        // One immediate replay before classifying — but only for requests the
        // allowlist proves read-only (`isReplaySafeRequest`). A lone 401 on
        // discovery/handshake traffic can be a transient upstream blip (a
        // proxy hiccup, a racing key rotation on the server), and stamping
        // reauthorization-required from a single sample forces a needless
        // reconnect; the replay itself is possible because every body this
        // adapter builds is buffered (`applyBody`), never a one-shot stream.
        // A side-effectful method (`tools/call`) never replays: a 401 does
        // not guarantee the server did no work first, so re-sending could
        // execute the action twice. Its single 401 classifies directly —
        // the invocation has already failed either way, and the
        // transient-blip concern only justified the retry on read-only