Function connectionFailure

packages/plugins/mcp/src/sdk/connection.ts:432–475

(
  transport: string,
  message: string,
  cause: unknown,
)

});

const connectionFailure = (
  transport: string,
  message: string,
  cause: unknown,
): McpConnectionError | McpOAuthReauthorizationRequired => {
  if (hasNestedOAuthReauthorization(cause)) {
    return new McpOAuthReauthorizationRequired({ message: "MCP OAuth re-authorization required" });
  }
  if (Predicate.isTagged(cause, "McpInsufficientScopeError")) {
    // Surfaced as a connection error with the 403 status; the invoke/connect
    // catch sites detect the tag and classify as oauth_scope_insufficient.
    return new McpConnectionError({
      transport,
      message: `${message} (HTTP 403: insufficient scope)`,
      httpStatus: 403,
      insufficientScope: true,
    });
  }
  const httpTransportError = nestedMcpHttpTransportError(cause);
  if (Option.isSome(httpTransportError)) {
    return new McpConnectionError({
      transport,
      message: CONNECTION_FAILURE_MESSAGES[httpTransportError.value.failureKind],
      failureKind: httpTransportError.value.failureKind,
    });
  }
  // Carry the handshake HTTP status structurally (and in the message for
  // humans) so the liveness health check can classify a rejected credential
  // as expired rather than a generic connection failure.
  const status = connectionHttpStatusFromCause(cause);
  const failureKind: McpConnectionFailureKind =
    isStreamableHttpProtocolError(cause) ||
    (status !== undefined && PROTOCOL_HTTP_STATUSES.has(status))
      ? "protocol"
      : status === undefined
        ? "network"
        : "http";
  return new McpConnectionError({
    transport,
    message: status === undefined ? message : `${message} (HTTP ${status})`,
    failureKind,
    ...(status === undefined ? {} : { httpStatus: status }),
  });
};

const connectionAttemptSummary = (failure: McpConnectionError): string => {
  if (failure.httpStatus !== undefined) return `HTTP ${failure.httpStatus}`;