feat(sdk,ffi): Add server_vendor_info method to matrix-sdk with automatic logging in FFI

Add a new `server_vendor_info` method on the `matrix-sdk` `Client` that calls the `/_matrix/federation/v1/version` endpoint to retrieve the server's software name and version information.

Also add it to the bindings + log it when initializing the logs.

Author: Copilot

Cargo.lock

@@ -1618,6 +1618,14 @@ impl Client {
             .any(|focus| matches!(focus, RtcFocusInfo::LiveKit(_))))
     }
 
+    /// Get server vendor information from the federation API.
+    ///
+    /// This method retrieves information about the server's name and version
+    /// by calling the `/_matrix/federation/v1/version` endpoint.
+    pub async fn server_vendor_info(&self) -> Result<matrix_sdk::ServerVendorInfo, ClientError> {
+        Ok(self.inner.server_vendor_info().await?)
+    }
+
     /// Subscribe to changes in the media preview configuration.
     pub async fn subscribe_to_media_preview_config(
         &self,

bindings/matrix-sdk-ffi/src/client.rs

@@ -574,6 +574,17 @@ impl ClientBuilder {
 
         let sdk_client = inner_builder.build().await?;
 
+        // Log server version information at info level.
+        if let Ok(server_info) = sdk_client.server_vendor_info().await {
+            tracing::info!(
+                server_name = %server_info.server_name,
+                version = %server_info.version,
+                "Connected to Matrix server"
+            );
+        } else {
+            tracing::warn!("Could not retrieve server version information");
+        }
+
         Ok(Arc::new(
             Client::new(
                 sdk_client,

bindings/matrix-sdk-ffi/src/client_builder.rs

@@ -101,6 +101,7 @@ pin-project-lite.workspace = true
 rand = { workspace = true, optional = true }
 ruma = { workspace = true, features = [
     "rand",
+    "federation-api-c",
     "unstable-msc2448",
     "unstable-msc4191",
     "unstable-msc3930",

crates/matrix-sdk/Cargo.toml

@@ -65,6 +65,7 @@ use ruma::{
             user_directory::search_users,
         },
         error::FromHttpResponseError,
+        federation::discovery::get_server_version,
         FeatureFlag, MatrixVersion, OutgoingRequest, SupportedVersions,
     },
     assign,
@@ -153,6 +154,16 @@ pub enum SessionChange {
     TokensRefreshed,
 }
 
+/// Information about the server vendor obtained from the federation API.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
+pub struct ServerVendorInfo {
+    /// The server name.
+    pub server_name: String,
+    /// The server version.
+    pub version: String,
+}
+
 /// An async/await enabled Matrix client.
 ///
 /// All of the state is held in an `Arc` so the `Client` can be cloned freely.
@@ -523,6 +534,38 @@ impl Client {
         Ok(res.capabilities)
     }
 
+    /// Get the server vendor information from the federation API.
+    ///
+    /// This method calls the `/_matrix/federation/v1/version` endpoint to get
+    /// both the server's software name and version.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// # use matrix_sdk::Client;
+    /// # use url::Url;
+    /// # async {
+    /// # let homeserver = Url::parse("http://example.com")?;
+    /// let client = Client::new(homeserver).await?;
+    ///
+    /// let server_info = client.server_vendor_info().await?;
+    /// println!(
+    ///     "Server: {}, Version: {}",
+    ///     server_info.server_name, server_info.version
+    /// );
+    /// # anyhow::Ok(()) };
+    /// ```
+    pub async fn server_vendor_info(&self) -> HttpResult<ServerVendorInfo> {
+        let res = self.send(get_server_version::v1::Request::new()).await?;
+
+        // Extract server info, using defaults if fields are missing.
+        let server = res.server.unwrap_or_default();
+        let server_name_str = server.name.unwrap_or_else(|| "unknown".to_owned());
+        let version = server.version.unwrap_or_else(|| "unknown".to_owned());
+
+        Ok(ServerVendorInfo { server_name: server_name_str, version })
+    }
+
     /// Get a copy of the default request config.
     ///
     /// The default request config is what's used when sending requests if no

crates/matrix-sdk/src/client/mod.rs

@@ -68,7 +68,8 @@ pub mod widget;
 pub use account::Account;
 pub use authentication::{AuthApi, AuthSession, SessionTokens};
 pub use client::{
-    sanitize_server_name, Client, ClientBuildError, ClientBuilder, LoopCtrl, SessionChange,
+    sanitize_server_name, Client, ClientBuildError, ClientBuilder, LoopCtrl, ServerVendorInfo,
+    SessionChange,
 };
 pub use error::{
     Error, HttpError, HttpResult, NotificationSettingsError, RefreshTokenError, Result,

crates/matrix-sdk/src/lib.rs

@@ -1384,6 +1384,12 @@ impl MatrixMockServer {
         )));
         self.mock_endpoint(mock, EnablePushRuleEndpoint).expect_default_access_token()
     }
+
+    /// Create a prebuilt mock for the federation version endpoint.
+    pub fn mock_federation_version(&self) -> MockEndpoint<'_, FederationVersionEndpoint> {
+        let mock = Mock::given(method("GET")).and(path("/_matrix/federation/v1/version"));
+        self.mock_endpoint(mock, FederationVersionEndpoint)
+    }
 }
 
 /// Parameter to [`MatrixMockServer::sync_room`].
@@ -3983,3 +3989,25 @@ impl<'a> MockEndpoint<'a, EnablePushRuleEndpoint> {
         self.ok_empty_json()
     }
 }
+
+/// A prebuilt mock for the federation version endpoint.
+pub struct FederationVersionEndpoint;
+
+impl<'a> MockEndpoint<'a, FederationVersionEndpoint> {
+    /// Returns a successful response with the given server name and version.
+    pub fn ok(self, server_name: &str, version: &str) -> MatrixMock<'a> {
+        let response_body = json!({
+            "server": {
+                "name": server_name,
+                "version": version
+            }
+        });
+        self.respond_with(ResponseTemplate::new(200).set_body_json(response_body))
+    }
+
+    /// Returns a successful response with empty/missing server information.
+    pub fn ok_empty(self) -> MatrixMock<'a> {
+        let response_body = json!({});
+        self.respond_with(ResponseTemplate::new(200).set_body_json(response_body))
+    }
+}

crates/matrix-sdk/src/test_utils/mocks/mod.rs

@@ -1490,3 +1490,36 @@ async fn test_room_sync_state_after() {
     let member = room.get_member_no_sync(user_id!("@invited:localhost")).await.unwrap().unwrap();
     assert_eq!(*member.membership(), MembershipState::Leave);
 }
+
+#[async_test]
+async fn test_server_vendor_info() {
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
+
+    let server = MatrixMockServer::new().await;
+    let client = server.client_builder().build().await;
+
+    // Mock the federation version endpoint
+    server.mock_federation_version().ok("Synapse", "1.70.0").mount().await;
+
+    let server_info = client.server_vendor_info().await.unwrap();
+
+    assert_eq!(server_info.server_name, "Synapse");
+    assert_eq!(server_info.version, "1.70.0");
+}
+
+#[async_test]
+async fn test_server_vendor_info_with_missing_fields() {
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
+
+    let server = MatrixMockServer::new().await;
+    let client = server.client_builder().build().await;
+
+    // Mock the federation version endpoint with missing fields
+    server.mock_federation_version().ok_empty().mount().await;
+
+    let server_info = client.server_vendor_info().await.unwrap();
+
+    // Should use defaults for missing fields
+    assert_eq!(server_info.server_name, "unknown");
+    assert_eq!(server_info.version, "unknown");
+}