Api(ChatNotFound) error after re-entering dialogue. Works fine the first time.

[MvCast]

Hi there,

I am playing with dialoges to handle callbacks in a sequence of multiple inline keyboards. What I have implemented works fine, for one time. After a single "cycle of the dialogue" has been completed, entering the command that initializes it again results in a ERROR teloxide::error_handlers > Error: Api(ChatNotFound) after making the first selection. I do not understand why it is working for one time and breaking after. It only happens with this part of the responsability tree, the rest works fine.

This is the branch of the responsability tree:

.branch(
        Update::filter_callback_query().enter_dialogue::<CallbackQuery, InMemStorage<State>, State>()
            .branch(dptree::case![State::Start].endpoint(my_callback_handler::first_callback_handler))
            .branch(dptree::case![State::SecondSelection].endpoint(my_callback_handler::second_callback_handler))
            .branch(dptree::case![State::End].endpoint(my_callback_handler::final_callback_handler))
                
        )

This is the function in which the error occurs:

pub async fn first_callback_handler(
    bot: Bot, 
    q: CallbackQuery, 
    dialogue: MyDialogue
) -> Result<(), Box<dyn Error + Send + Sync>> {
    if let Some(answer) = q.data {
        let text = format!("You chose: {answer}");

        bot.answer_callback_query(q.id).await?;

        if let Some(Message {id, chat, ..}) = q.message {
            bot.edit_message_text(chat.id, id, text).await?;

            let my_keyboard = create_second_keyboard();
            bot.send_message(chat.id, "This is the second part").reply_markup(my_keyboard).await?;
        }
    }

    dialogue.update(State::SecondSelection).await?;
    Ok(())
}

And these are the other two functions that I use in the sequence:

pub async fn second_callback_handler(
    bot: Bot, 
    q: CallbackQuery, 
    dialogue: MyDialogue
) -> Result<(), Box<dyn Error + Send + Sync>> {
    if let Some(answer) = q.data {
        let text = format!("The second selection: {answer}");

        bot.answer_callback_query(q.id).await?;

        if let Some(Message {id, chat, ..}) = q.message {
            bot.edit_message_text(chat.id, id, text).await?;
        }
    }

    dialogue.update(State::End).await?;
    Ok(())
}

pub async fn final_callback_handler(
    bot: Bot, 
    q: CallbackQuery, 
    dialogue: MyDialogue
) -> Result<(), Box<dyn Error + Send + Sync>> {
    bot.answer_callback_query(&q.id).await?;
    bot.send_message(q.id, "End of the test").await?;

    dialogue.exit().await?;
    Ok(())
}

To finalize the definition of the subsystem:

#[derive(Clone, Default)]
pub enum State {
    #[default]
    Start,
    SecondSelection,
    End,
}