Method swap_agent

crates/chat-cli/src/cli/chat/tool_manager.rs:649–700

Swapping agent involves the following: - Dropping all of the clients first to avoid resource contention - Clearing fields that are already referenced by background tasks. We can't simply spawn new instances of these fields because one or more background tasks are already depending on it - Building a new tool manager builder from the current tool manager - Building a tool manager from said tool man

(&mut self, os: &mut Os, output: &mut impl Write, agent: &Agent)

    ///   function)
    /// - Calling load tools
    pub async fn swap_agent(&mut self, os: &mut Os, output: &mut impl Write, agent: &Agent) -> eyre::Result<()> {
        let to_evict = self.clients.drain().collect::<Vec<_>>();
        tokio::spawn(async move {
            for (server_name, initialized_client) in to_evict {
                info!("Evicting {server_name} due to agent swap");
                match initialized_client {
                    InitializedMcpClient::Pending(handle) => {
                        let server_name_clone = server_name.clone();
                        tokio::spawn(async move {
                            match handle.await {
                                Ok(Ok(client)) => {
                                    let InnerService::Original(client) = client.inner_service else {
                                        unreachable!();
                                    };
                                    match client.cancel().await {
                                        Ok(_) => info!("Server {server_name_clone} evicted due to agent swap"),
                                        Err(e) => error!("Server {server_name_clone} has failed to cancel: {e}"),
                                    }
                                },
                                Ok(Err(_)) | Err(_) => {
                                    error!("Server {server_name_clone} has failed to cancel");
                                },
                            }
                        });
                    },
                    InitializedMcpClient::Ready(running_service) => {
                        let InnerService::Original(client) = running_service.inner_service else {
                            unreachable!();
                        };
                        match client.cancel().await {
                            Ok(_) => info!("Server {server_name} evicted due to agent swap"),
                            Err(e) => error!("Server {server_name} has failed to cancel: {e}"),
                        }
                    },
                }
            }
        });

        let mut agent_lock = self.agent.lock().await;
        *agent_lock = agent.clone();
        drop(agent_lock);

        self.mcp_load_record.lock().await.clear();

        let builder = ToolManagerBuilder::from(&mut *self);
        let mut new_tool_manager = builder.build(os, Box::new(std::io::sink()), true).await?;
        std::mem::swap(self, &mut new_tool_manager);

        self.load_tools(os, output).await?;

        Ok(())
    }

    pub async fn load_tools(
        &mut self,