Fix CI failures: type alignment, non-exhaustive match, formatting

- Simplify Transport enum to use Option<reqwest::Client> instead of AuthClient wrapper
- Fix error_to_user_message to add wildcard arm for non-exhaustive RmcpError
- Remove duplicate function signature line
- Run cargo fmt

Co-Authored-By: Oz <oz-agent@warp.dev>

Author: acarl005

app/src/ai/mcp/http_client.rs

@@ -1,7 +1,7 @@
 use std::{borrow::Cow, collections::HashMap, sync::Arc};
 
-use futures::{StreamExt, stream::BoxStream};
-use http::{HeaderName, HeaderValue, header::WWW_AUTHENTICATE};
+use futures::{stream::BoxStream, StreamExt};
+use http::{header::WWW_AUTHENTICATE, HeaderName, HeaderValue};
 use reqwest::header::{HeaderMap, ACCEPT};
 use rmcp::{
     model::{ClientJsonRpcMessage, JsonRpcMessage, ServerJsonRpcMessage},
@@ -65,7 +65,9 @@ fn apply_custom_headers(
     for (name, value) in custom_headers {
         let name_lower = name.as_str().to_lowercase();
         if RESERVED_HEADERS.contains(&name_lower.as_str()) {
-            return Err(StreamableHttpError::ReservedHeaderConflict(name.to_string()));
+            return Err(StreamableHttpError::ReservedHeaderConflict(
+                name.to_string(),
+            ));
         }
         builder = builder.header(name, value);
     }
@@ -107,7 +109,8 @@ impl StreamableHttpClient for McpHttpClient {
         auth_token: Option<String>,
         custom_headers: HashMap<HeaderName, HeaderValue>,
     ) -> Result<BoxStream<'static, Result<Sse, SseError>>, StreamableHttpError<Self::Error>> {
-        let mut request_builder = self.0
+        let mut request_builder = self
+            .0
             .get(uri.as_ref())
             .header(ACCEPT, [EVENT_STREAM_MIME_TYPE, JSON_MIME_TYPE].join(", "))
             .header(HEADER_SESSION_ID, session_id.as_ref());
@@ -181,7 +184,8 @@ impl StreamableHttpClient for McpHttpClient {
         auth_token: Option<String>,
         custom_headers: HashMap<HeaderName, HeaderValue>,
     ) -> Result<StreamableHttpPostResponse, StreamableHttpError<Self::Error>> {
-        let mut request = self.0
+        let mut request = self
+            .0
             .post(uri.as_ref())
             .header(ACCEPT, [EVENT_STREAM_MIME_TYPE, JSON_MIME_TYPE].join(", "));
         if let Some(auth_header) = auth_token {
@@ -207,9 +211,9 @@ impl StreamableHttpClient for McpHttpClient {
                         ))
                     })?
                     .to_string();
-                return Err(StreamableHttpError::AuthRequired(
-                    AuthRequiredError::new(header),
-                ));
+                return Err(StreamableHttpError::AuthRequired(AuthRequiredError::new(
+                    header,
+                )));
             }
         }
         if response.status() == reqwest::StatusCode::FORBIDDEN {

app/src/ai/mcp/templatable_manager/native.rs

@@ -157,6 +157,7 @@ fn error_to_user_message(error: &rmcp::RmcpError) -> String {
             }
             _ => format!("Service error: {}", err),
         },
+        _ => format!("Error: {}", error),
     }
 }
 
@@ -1852,7 +1853,7 @@ async fn spawn_server(
 
                     logger.log("[info] MCP: Using Streaming HTTP transport".to_string());
                     let transport = rmcp::transport::StreamableHttpClientTransport::with_client(
-                        crate::ai::mcp::http_client::McpHttpClient(client.http_client),
+                        crate::ai::mcp::http_client::McpHttpClient(client),
                         rmcp::transport::streamable_http_client::StreamableHttpClientTransportConfig::with_uri(
                             sse_server.url.clone(),
                         ),
@@ -1869,7 +1870,9 @@ async fn spawn_server(
                         let client = if headers.is_empty() {
                             crate::ai::mcp::http_client::McpHttpClient::default()
                         } else {
-                            crate::ai::mcp::http_client::McpHttpClient(build_client_with_headers(&headers)?)
+                            crate::ai::mcp::http_client::McpHttpClient(build_client_with_headers(
+                                &headers,
+                            )?)
                         };
                         rmcp::transport::StreamableHttpClientTransport::with_client(
                             client,
@@ -1890,7 +1893,9 @@ async fn spawn_server(
                         let client = if headers.is_empty() {
                             crate::ai::mcp::http_client::McpHttpClient::default()
                         } else {
-                            crate::ai::mcp::http_client::McpHttpClient(build_client_with_headers(&headers)?)
+                            crate::ai::mcp::http_client::McpHttpClient(build_client_with_headers(
+                                &headers,
+                            )?)
                         };
                         rmcp::transport::StreamableHttpClientTransport::with_client(
                             client,
@@ -1955,7 +1960,7 @@ async fn spawn_server(
 /// The transport to use for MCP.
 enum Transport {
     /// The HTTP transport, with an optional authenticated client.
-    Http(Option<rmcp::transport::auth::AuthClient<crate::ai::mcp::http_client::McpHttpClient>>),
+    Http(Option<reqwest::Client>),
     /// Legacy SSE transport (server responded with 404 to HTTP transport check).
     LegacySse,
 }
@@ -1991,18 +1996,15 @@ async fn determine_transport(
             let spawner = auth_context.spawner.clone();
             // Go through the OAuth flow to get an authenticated client.
             // This will first attempt to use cached credentials before starting interactive OAuth.
-            let (client, did_require_login) = oauth::make_authenticated_client(url, auth_context)
-                .boxed()
-                .await
-                .map_err(rmcp::RmcpError::transport_creation::<ReqwestHttpTransport>)?;
-            let mcp_client = rmcp::transport::auth::AuthClient::new(
-                crate::ai::mcp::http_client::McpHttpClient(client.http_client),
-                client.auth_manager.lock().await.clone(),
-            );
-            let transport = match send_initialize_request(url, headers, Some(&mcp_client)).await? {
-                StatusCode::OK => Ok(Transport::Http(Some(client))),
+            let (auth_client, did_require_login) =
+                oauth::make_authenticated_client(url, auth_context)
+                    .boxed()
+                    .await
+                    .map_err(rmcp::RmcpError::transport_creation::<ReqwestHttpTransport>)?;
+            let transport = match send_initialize_request(url, headers, Some(&auth_client)).await? {
+                StatusCode::OK => Ok(Transport::Http(Some(auth_client.http_client.clone()))),
                 StatusCode::NOT_FOUND | StatusCode::METHOD_NOT_ALLOWED => {
-                    Ok(Transport::Http(Some(client)))
+                    Ok(Transport::Http(Some(auth_client.http_client.clone())))
                 }
                 other => Err(unexpected_error(other)),
             };
@@ -2034,7 +2036,7 @@ async fn determine_transport(
 async fn send_initialize_request(
     url: &str,
     headers: &std::collections::HashMap<String, String>,
-    auth_client: Option<&rmcp::transport::auth::AuthClient<crate::ai::mcp::http_client::McpHttpClient>>,
+    auth_client: Option<&rmcp::transport::auth::AuthClient<reqwest::Client>>,
 ) -> Result<reqwest::StatusCode, rmcp::RmcpError> {
     use rmcp::transport::common::http_header::{EVENT_STREAM_MIME_TYPE, JSON_MIME_TYPE};
 

app/src/ai/mcp/templatable_manager/oauth.rs

@@ -240,7 +240,7 @@ pub async fn make_authenticated_client(
             // If this is a client for which we have a known client secret,
             // update our client config accordingly.
             if let Some(client_secret) = &client_secret {
-            auth_manager.configure_client(
+                auth_manager.configure_client(
                     OAuthClientConfig::new(credentials.client_id.clone(), redirect_uri.clone())
                         .with_client_secret(client_secret.clone()),
                 )?;
@@ -319,7 +319,10 @@ pub async fn make_authenticated_client(
     // For apps for which we have static client IDs (e.g. GitHub), we manually override scopes.
     let mut scopes: &[&str] = &[];
 
-    let config = match auth_manager.register_client("Warp", &redirect_uri, scopes).await {
+    let config = match auth_manager
+        .register_client("Warp", &redirect_uri, scopes)
+        .await
+    {
         Ok(config) => config,
         Err(err @ AuthError::RegistrationFailed(_)) => {
             // If we failed dynamic registration, check to see if this is an auth