What is the alternative of downcasting a trait object in this situation?

Question

I have a Companion trait that encompasses a base trait for Components such as Health. I store a list of Companion using trait objects because all companions must at least implement the Companion trait. However not all companions will use the subtype Health trait.

Now the heal command only accepts a list of Health traits, so I need to filter out, remap and downcast all the base Companion traits so that it supports the Health traits.

I understand this is bad design. How can I implement the same behavior without having to downcast the trait objects to a specific component? Note: I cannot have a large struct which includes all the subtypes into one type.

Here's the code I have so far:

type CompanionId = Uuid;

fn main() {
    let mut companion_storage: HashMap<CompanionId, Box<dyn Companion>> = HashMap::new();
    let companion_id: CompanionId = Uuid::new_v4();
    companion_storage.insert(
        companion_id,
        Box::new(Cheetah {
            ...
        }),
    );
    let mut player = Player {
        ...,
        companions: Vec::new(),
    };
    player.companions.push(companion_id);

    'GameLoop: loop {
        let input = poll_input().trim().to_lowercase();

        match input.as_str() {
            // TODO: Extract healing component here.
            "heal" => heal_command(companion_id, companion_storage.into_iter().filter(|(companion_id, companion)| {
                // QUESTION: How do I filter out Companions without the Health trait here so they can automatically be downcasted and mapped?
            }).collect()),
            "q" => {
                break 'GameLoop;
            }
            "s" => {
                status_command(&player, &companion_storage); // SAME PROBLEM HERE
            }
            _ => println!("Unknown command"),
        }
    }
}

struct Player {
    id: u8,
    name: String,
    companions: Vec<CompanionId>,
}

trait Companion {
    ...
}

trait Health: Companion {
   ...
}

trait Status: Health {}

struct Cheetah {
    id: CompanionId,
    name: String,
    current_health: f32,
    max_health: f32,
}

impl Companion for Cheetah {
    ...
}

impl Health for Cheetah {
    ...
}

fn heal_command(
    companion_id: CompanionId,
    companion_storage: &mut HashMap<CompanionId, Box<dyn Health>>,
) {
    let companion = companion_storage.get_mut(&companion_id).unwrap();

    companion.heal_max();

    println!("Healed to max.");
}

fn status_command(player: &Player, companion_storage: &mut HashMap<CompanionId, Box<dyn Status>>) {
    println!("Status for {}: ", player.name);
    println!("===============================");
    print!("Companions: ");
    for companion_id in &player.companions {
        let companion = companion_storage.get(companion_id).unwrap();

        print!(
            "{} [{}/{}], ",
            companion.name(),
            companion.health(),
            companion.max_health()
        );
    }
    println!();
    println!("===============================");
}

Is this code a better alternative?

type CompanionId = Uuid;

fn main() {
    let mut companion_storage: HashMap<CompanionId, Companion> = HashMap::new();
    let companion_id: CompanionId = Uuid::new_v4();
    companion_storage.insert(
        companion_id,
        Companion {
            id: companion_id,
            name: "Cheetah".to_string(),
            health: Some(Box::new(RegularHealth {
                current_health: 50.0,
                max_health: 50.0,
            })),
        },
    );
    let mut player = Player {
        id: 0,
        name: "FyiaR".to_string(),
        companions: Vec::new(),
    };
    player.companions.push(companion_id);

    'GameLoop: loop {
        let input = poll_input().trim().to_lowercase();

         match input.as_str() {
            // TODO: Extract healing component here.
            "heal" => {
                let companion = companion_storage.get_mut(&companion_id).unwrap();

                match companion.health_mut() {
                    None => {
                        println!("The selected companion doesn't have health associated with it.");
                    }
                    Some(health) => {
                        heal_command(health);

                        println!("{} was healed to max.", companion.name);
                    }
                }
            }
            "q" => {
                break 'GameLoop;
            }
            "s" => {
                status_command(&player, &companion_storage); // SAME PROBLEM HERE
            }
            _ => println!("Unknown command"),
        }
    }
}

struct Player {
    id: u8,
    name: String,
    companions: Vec<CompanionId>,
}

struct Companion {
    id: CompanionId,
    name: String,
    health: Option<Box<dyn Health>>,
}

struct RegularHealth {
    current_health: f32,
    max_health: f32,
}

trait Health {
    ...
}

impl Companion {
    fn health_mut(&mut self) -> Option<&mut dyn Health> {
        match self.health.as_mut() {
            None => None,
            Some(health) => Some(health.as_mut()),
        }
    }

    fn health(&self) -> Option<&dyn Health> {
        match self.health.as_ref() {
            None => None,
            Some(health) => Some(health.as_ref()),
        }
    }
}

impl Health for RegularHealth {
    ...
}

fn heal_command(health: &mut dyn Health) {
    health.heal_max();
}

fn status_command(player: &Player, companion_storage: &HashMap<CompanionId, Companion>) {
    println!("Status for {}: ", player.name);
    println!("===============================");
    print!("Companions: ");
    for companion_id in &player.companions {
        let companion = companion_storage.get(companion_id).unwrap();

        match companion.health.as_ref() {
            None => {}
            Some(health) => {
                print!(
                    "{} [{}/{}], ",
                    companion.name,
                    health.health(),
                    health.max_health()
                );
            }
        }
    }
    println!();
    println!("===============================");
}