Method init

crates/chat-cli/src/mcp_client/client.rs:285–380

(self, os: &Os)

    }

    pub async fn init(self, os: &Os) -> Result<InitializedMcpClient, McpClientError> {
        let os_clone = os.clone();

        let handle: JoinHandle<Result<RunningService, McpClientError>> = tokio::spawn(async move {
            let messenger_clone = self.messenger.clone();
            let server_name = self.server_name.clone();

            let (service, child_stderr, auth_dropguard) = match self.into_service(&os_clone, &messenger_clone).await {
                Ok((service, stderr, auth_dg)) => (service, stderr, auth_dg),
                Err(e) => {
                    let msg = e.to_string();
                    let error_data = ErrorData {
                        code: ErrorCode::RESOURCE_NOT_FOUND,
                        message: Cow::from(msg),
                        data: None,
                    };
                    let err = ServiceError::McpError(error_data);

                    if let Err(send_err) = messenger_clone.send_tools_list_result(Err(err), None).await {
                        error!("Error sending tool result for {server_name}: {send_err}");
                    }

                    return Err(e);
                },
            };

            if let Some(mut stderr) = child_stderr {
                let server_name_clone = server_name.clone();
                tokio::spawn(async move {
                    let mut buf = [0u8; 1024];
                    loop {
                        match stderr.read(&mut buf).await {
                            Ok(0) => {
                                tracing::info!(target: "mcp", "{server_name_clone} stderr listening process exited due to EOF");
                                break;
                            },
                            Ok(size) => {
                                tracing::info!(target: "mcp", "{server_name_clone} logged to its stderr: {}", String::from_utf8_lossy(&buf[0..size]));
                            },
                            Err(e) => {
                                tracing::info!(target: "mcp", "{server_name_clone} stderr listening process exited due to error: {e}");
                                break; // Error reading
                            },
                        }
                    }
                });
            }

            let service_clone = service.clone();
            tokio::spawn(async move {
                let result: Result<(), Box<dyn std::error::Error + Send + Sync>> = async {
                    let init_result = service_clone.peer_info();
                    if let Some(init_result) = init_result {
                        if init_result.capabilities.tools.is_some() {
                            paginated_fetch! {
                                final_result_type: ListToolsResult,
                                content_type: rmcp::model::Tool,
                                service_method: list_tools,