chore: upgrade rmcp to v1.5

rmcp went from 0.17.0 to 1.x with a hard cutover: most of its public
model and transport types picked up `#[non_exhaustive]`, `OAuthTokenResponse`
switched from `EmptyExtraTokenFields` to `VendorExtraTokenFields`, and
`StreamableHttpServerConfig` gained a required `allowed_hosts` field.
This commit migrates every call site in the gateway, MCP adapter,
credential store, and streamable-HTTP tests onto the new constructors
(`Implementation::new`, `ClientInfo::new`, `ServerInfo::new`,
`InitializeResult::new`, `CallToolRequestParams::new`,
`ReadResourceResult::new`, `GetPromptRequestParams::new`,
`OAuthClientConfig::new`, `StoredCredentials::new`,
`CallToolResult::success` / `::error`, `AuthorizationSession::for_scope_upgrade`,
`StreamableHttpServerConfig::default()`), bumps the `tests/rust` crate to
the same rmcp 1.5 so only one version is linked into the workspace,
and resolves a handful of latent clippy warnings (`op_ref` in
keychain_dpapi test, unused `use super::*` in shell_env on Windows) that
became reachable via `--all-targets`.

Signed-off-by: Mohammod Al Amin Ashik <maa.ashik00@gmail.com>

Author: its-mash

Cargo.lock

@@ -58,7 +58,7 @@ os_pipe = "1"
 
 # MCP Protocol
 # NOTE: Never use local path dependency - E:\one-mcp\rust-sdk is for source lookup only
-rmcp = { version = "0.17.0", features = [
+rmcp = { version = "1.5", features = [
     "client",
     "server",
     "transport-io",

Cargo.toml

@@ -83,12 +83,12 @@ impl McpMuxGatewayHandler {
 
     /// Build InitializeResult with negotiated protocol version
     fn build_initialize_result(&self, protocol_version: ProtocolVersion) -> InitializeResult {
-        InitializeResult {
-            protocol_version,
-            capabilities: self.get_info().capabilities,
-            server_info: self.get_info().server_info,
-            instructions: self.get_info().instructions,
-        }
+        let info = self.get_info();
+        let mut result = InitializeResult::new(info.capabilities);
+        result.protocol_version = protocol_version;
+        result.server_info = info.server_info;
+        result.instructions = info.instructions;
+        result
     }
 }
 
@@ -98,32 +98,28 @@ impl ServerHandler for McpMuxGatewayHandler {
 
         // Note: get_info is called frequently, no logging needed
 
-        ServerInfo {
-            protocol_version: Default::default(),
-            capabilities: ServerCapabilities::builder()
-                .enable_tools_with(ToolsCapability {
-                    list_changed: Some(true),
-                })
-                .enable_prompts_with(PromptsCapability {
-                    list_changed: Some(true),
-                })
-                .enable_resources_with(ResourcesCapability {
-                    subscribe: Some(false),
-                    list_changed: Some(true),
-                })
-                .build(),
-            server_info: Implementation {
-                name: "mcpmux-gateway".to_string(),
-                version: env!("CARGO_PKG_VERSION").to_string(),
-                title: Some("McpMux".to_string()),
-                ..Default::default()
-            },
-            instructions: Some(
-                "McpMux aggregates multiple MCP servers. Use tools/prompts/resources \
-                 from your authorized backend servers."
-                    .to_string(),
-            ),
-        }
+        let capabilities = ServerCapabilities::builder()
+            .enable_tools_with(ToolsCapability {
+                list_changed: Some(true),
+            })
+            .enable_prompts_with(PromptsCapability {
+                list_changed: Some(true),
+            })
+            .enable_resources_with(ResourcesCapability {
+                subscribe: Some(false),
+                list_changed: Some(true),
+            })
+            .build();
+        let mut server_info = Implementation::new("mcpmux-gateway", env!("CARGO_PKG_VERSION"));
+        server_info.title = Some("McpMux".to_string());
+        let mut info = ServerInfo::new(capabilities);
+        info.server_info = server_info;
+        info.instructions = Some(
+            "McpMux aggregates multiple MCP servers. Use tools/prompts/resources \
+             from your authorized backend servers."
+                .to_string(),
+        );
+        info
     }
 
     async fn initialize(
@@ -321,11 +317,10 @@ impl ServerHandler for McpMuxGatewayHandler {
             "call_tool result"
         );
 
-        let result = CallToolResult {
-            content,
-            structured_content: None,
-            is_error: Some(tool_result.is_error),
-            meta: None,
+        let result = if tool_result.is_error {
+            CallToolResult::error(content)
+        } else {
+            CallToolResult::success(content)
         };
 
         Ok(result)
@@ -557,7 +552,7 @@ impl ServerHandler for McpMuxGatewayHandler {
             .filter_map(|v| serde_json::from_value(v).ok())
             .collect();
 
-        Ok(ReadResourceResult { contents })
+        Ok(ReadResourceResult::new(contents))
     }
 
     /// Override on_custom_request to handle "initialize" with flexible protocol negotiation

crates/mcpmux-gateway/src/mcp/handler.rs

@@ -218,37 +218,37 @@ impl CredentialStore for DatabaseCredentialStore {
                     self.space_id, self.server_id, reg.client_id
                 );
                 let token_response = Self::build_token_response(access, refresh_cred.as_ref());
-                Some(StoredCredentials {
-                    client_id: reg.client_id,
-                    token_response: Some(token_response),
-                    granted_scopes: Vec::new(),
-                    token_received_at: Some(now_epoch_secs()),
-                })
+                Some(StoredCredentials::new(
+                    reg.client_id,
+                    Some(token_response),
+                    Vec::new(),
+                    Some(now_epoch_secs()),
+                ))
             }
             (Some(reg), None) => {
                 debug!(
                     "[CredentialStore] Loaded registration (no token) for {}/{}, client_id={} - will reuse for DCR",
                     self.space_id, self.server_id, reg.client_id
                 );
-                Some(StoredCredentials {
-                    client_id: reg.client_id,
-                    token_response: None,
-                    granted_scopes: Vec::new(),
-                    token_received_at: Some(now_epoch_secs()),
-                })
+                Some(StoredCredentials::new(
+                    reg.client_id,
+                    None,
+                    Vec::new(),
+                    Some(now_epoch_secs()),
+                ))
             }
             (None, Some(access)) => {
                 warn!(
                     "[CredentialStore] Token without registration for {}/{}",
                     self.space_id, self.server_id
                 );
                 let token_response = Self::build_token_response(access, refresh_cred.as_ref());
-                Some(StoredCredentials {
-                    client_id: String::new(),
-                    token_response: Some(token_response),
-                    granted_scopes: Vec::new(),
-                    token_received_at: Some(now_epoch_secs()),
-                })
+                Some(StoredCredentials::new(
+                    String::new(),
+                    Some(token_response),
+                    Vec::new(),
+                    Some(now_epoch_secs()),
+                ))
             }
             (None, None) => {
                 debug!(
@@ -286,12 +286,13 @@ fn build_token_response(
     refresh_token: Option<String>,
     expires_in: Option<std::time::Duration>,
 ) -> OAuthTokenResponse {
-    use oauth2::{EmptyExtraTokenFields, StandardTokenResponse};
+    use oauth2::StandardTokenResponse;
+    use rmcp::transport::auth::VendorExtraTokenFields;
 
     let mut response = StandardTokenResponse::new(
         AccessToken::new(access_token),
         BasicTokenType::Bearer,
-        EmptyExtraTokenFields {},
+        VendorExtraTokenFields::default(),
     );
 
     if let Some(refresh) = refresh_token {
@@ -601,12 +602,12 @@ mod tests {
             Some(std::time::Duration::from_secs(3600)),
         );
 
-        let credentials = StoredCredentials {
-            client_id: "new-client-id".to_string(),
-            token_response: Some(token_response),
-            granted_scopes: Vec::new(),
-            token_received_at: None,
-        };
+        let credentials = StoredCredentials::new(
+            "new-client-id".to_string(),
+            Some(token_response),
+            Vec::new(),
+            None,
+        );
 
         store.save(credentials).await.unwrap();
 
@@ -660,12 +661,12 @@ mod tests {
             Some(std::time::Duration::from_secs(3600)),
         );
 
-        let credentials = StoredCredentials {
-            client_id: "client-id".to_string(),
-            token_response: Some(token_response),
-            granted_scopes: Vec::new(),
-            token_received_at: None,
-        };
+        let credentials = StoredCredentials::new(
+            "client-id".to_string(),
+            Some(token_response),
+            Vec::new(),
+            None,
+        );
 
         store.save(credentials).await.unwrap();
 

crates/mcpmux-gateway/src/pool/credential_store.rs

@@ -50,20 +50,11 @@ impl McpClientHandler {
         event_tx: Option<tokio::sync::broadcast::Sender<DomainEvent>>,
         log_manager: Option<Arc<ServerLogManager>>,
     ) -> Self {
+        let mut client_info =
+            Implementation::new(format!("mcpmux-{}", server_id), env!("CARGO_PKG_VERSION"));
+        client_info.title = Some("McpMux Gateway".to_string());
         Self {
-            info: ClientInfo {
-                protocol_version: Default::default(),
-                capabilities: ClientCapabilities::default(),
-                client_info: Implementation {
-                    name: format!("mcpmux-{}", server_id),
-                    version: env!("CARGO_PKG_VERSION").to_string(),
-                    title: Some("McpMux Gateway".to_string()),
-                    icons: None,
-                    website_url: None,
-                    ..Default::default()
-                },
-                meta: None,
-            },
+            info: ClientInfo::new(ClientCapabilities::default(), client_info),
             server_id: server_id.to_string(),
             space_id,
             event_tx,

crates/mcpmux-gateway/src/pool/instance.rs

@@ -1049,12 +1049,11 @@ impl OutboundOAuthManager {
                 let scopes = Self::get_scopes_from_metadata(&discovered_metadata);
 
                 // Then configure client with the existing registration
-                let config = rmcp::transport::auth::OAuthClientConfig {
-                    client_id: reg.client_id.clone(),
-                    client_secret: None,
-                    scopes: scopes.clone(),
-                    redirect_uri: redirect_uri.clone(),
-                };
+                let mut config = rmcp::transport::auth::OAuthClientConfig::new(
+                    reg.client_id.clone(),
+                    redirect_uri.clone(),
+                );
+                config.scopes = scopes.clone();
 
                 if let Err(e) = manager.configure_client(config) {
                     self.log(
@@ -1084,17 +1083,23 @@ impl OutboundOAuthManager {
                     .await
                     .map_err(|e| anyhow::anyhow!("Failed to get auth URL: {}", e))?;
 
-                // Create session manually
-                oauth_state = OAuthState::Session(rmcp::transport::auth::AuthorizationSession {
-                    auth_manager: std::mem::replace(
-                        manager,
-                        rmcp::transport::auth::AuthorizationManager::new(server_url)
-                            .await
-                            .map_err(|e| anyhow::anyhow!("Failed: {}", e))?,
+                // Create session manually (reusing the existing registration).
+                // We already called configure_client + get_authorization_url above,
+                // so we use `for_scope_upgrade` to wrap the pre-computed values without
+                // re-registering the client via DCR.
+                let taken_manager = std::mem::replace(
+                    manager,
+                    rmcp::transport::auth::AuthorizationManager::new(server_url)
+                        .await
+                        .map_err(|e| anyhow::anyhow!("Failed: {}", e))?,
+                );
+                oauth_state = OAuthState::Session(
+                    rmcp::transport::auth::AuthorizationSession::for_scope_upgrade(
+                        taken_manager,
+                        auth_url.clone(),
+                        &redirect_uri,
                     ),
-                    auth_url: auth_url.clone(),
-                    redirect_uri: redirect_uri.clone(),
-                });
+                );
             }
             (false, None) // Not a new registration, no metadata to save
         } else {

crates/mcpmux-gateway/src/pool/oauth.rs

@@ -101,17 +101,16 @@ pub fn convert_to_stored_metadata(metadata: &AuthorizationMetadata) -> StoredOAu
 /// This is used when loading saved metadata and setting it on the RMCP manager
 /// to bypass discovery.
 pub fn convert_from_stored_metadata(stored: &StoredOAuthMetadata) -> AuthorizationMetadata {
-    AuthorizationMetadata {
-        authorization_endpoint: stored.authorization_endpoint.clone(),
-        token_endpoint: stored.token_endpoint.clone(),
-        registration_endpoint: stored.registration_endpoint.clone(),
-        issuer: stored.issuer.clone(),
-        jwks_uri: stored.jwks_uri.clone(),
-        scopes_supported: stored.scopes_supported.clone(),
-        response_types_supported: stored.response_types_supported.clone(),
-        additional_fields: stored.additional_fields.clone(),
-        ..Default::default()
-    }
+    let mut metadata = AuthorizationMetadata::default();
+    metadata.authorization_endpoint = stored.authorization_endpoint.clone();
+    metadata.token_endpoint = stored.token_endpoint.clone();
+    metadata.registration_endpoint = stored.registration_endpoint.clone();
+    metadata.issuer = stored.issuer.clone();
+    metadata.jwks_uri = stored.jwks_uri.clone();
+    metadata.scopes_supported = stored.scopes_supported.clone();
+    metadata.response_types_supported = stored.response_types_supported.clone();
+    metadata.additional_fields = stored.additional_fields.clone();
+    metadata
 }
 
 #[cfg(test)]

crates/mcpmux-gateway/src/pool/oauth_utils.rs

@@ -283,12 +283,8 @@ impl RoutingService {
 
             match client_handle {
                 Some(client) => {
-                    let params = CallToolRequestParams {
-                        name: tool_name.into(),
-                        arguments: args.as_object().cloned(),
-                        task: None,
-                        meta: None,
-                    };
+                    let mut params = CallToolRequestParams::new(tool_name.to_string());
+                    params.arguments = args.as_object().cloned();
 
                     // Wrap call_tool with timeout to prevent hanging
                     let res = tokio::time::timeout(TOOL_CALL_TIMEOUT, client.call_tool(params))

crates/mcpmux-gateway/src/pool/routing.rs

@@ -164,10 +164,7 @@ impl PoolService {
             Some(client) => {
                 use rmcp::model::ReadResourceRequestParams;
 
-                let params = ReadResourceRequestParams {
-                    uri: uri.into(),
-                    meta: None,
-                };
+                let params = ReadResourceRequestParams::new(uri);
 
                 let res = client
                     .read_resource(params)
@@ -243,11 +240,8 @@ impl PoolService {
             Some(client) => {
                 use rmcp::model::GetPromptRequestParams;
 
-                let params = GetPromptRequestParams {
-                    name: prompt_name.into(),
-                    arguments,
-                    meta: None,
-                };
+                let mut params = GetPromptRequestParams::new(prompt_name);
+                params.arguments = arguments;
 
                 let res = client
                     .get_prompt(params)