unique ptr polymorphism in function parameters on a pure virtual class: invalid new-expression of abstract class

Here is a little challenge.

I have a base class X (nonvirtual) and a child class Y that adds some dependency-specific implementation.

I also have a pure-virtual base A that defines an interface in terms of X, and class B that adds some dependency-specific implementation and relies on Y features.

class X {
public:
  //rule of 0 applies
  double getSomething() {return something;}
  void setSomething(const double s) {something = s;}

private:
  double something{0};
};

class Y : public X {
public:
  //rule of 0 applies
  int getSomethingElse() {return somethingElse;}
  void setSomethingElse(const int s) {somethingElse = s;}
};

The fun begins here!

class A {
public:
  virtual void foo(std::unique_ptr<X> basePtr) = 0;
  virtual ~A() = default;
protected:
  A() = default;
}

class B : public A {
public:
  void foo(std::unique_ptr<Y> derivedPtr) {
    std::cout << "Something " + derivedPtr->getSomething() + " SomethingElse " + derivedPtr->getSomethingElse();
  }
}

The error occurs when attempting to std::make_shared<B>():

invalid new-expression of abstract class type 'B' {...}

... note: because the following virtual functions are pure within `B`:
  class B : public A {
        ^
... note: virtual void foo(std::unique_ptr<A>) = 0;
                       ^~~

I can think of one solution, that would be to have the B::foo signature in terms of X and to cast the argument to a std::unique_ptr<Y> in its definition, but I'm wondering if something cleaner exists.