Skip to content

Commit e0c44c0

Browse files
hashemixhashemix
authored
refactor: switch mcp http to framework-agnostic McpHttpError (#144)
* feat: introduce framework-agnostic McpHttpError type * refactor: switch mcp_http layer to framework-agnostic McpHttpError
1 parent 2e3c4ca commit e0c44c0

13 files changed

Lines changed: 147 additions & 150 deletions

File tree

‎crates/rust-mcp-extra/src/auth_provider/keycloak.rs‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -12,11 +12,11 @@ use rust_mcp_sdk::{
1212
OauthProtectedResourceMetadata, OauthTokenVerifier,
1313
},
1414
error::McpSdkError,
15-
mcp_http::{middleware::CorsMiddleware, GenericBody, GenericBodyExt, Middleware},
16-
mcp_server::{
17-
error::{TransportServerError, TransportServerResult},
18-
join_url, McpAppState,
15+
mcp_http::{
16+
middleware::CorsMiddleware, GenericBody, GenericBodyExt, McpAppState, McpHttpError,
17+
McpHttpResult, Middleware,
1918
},
19+
mcp_server::join_url,
2020
};
2121
use std::{collections::HashMap, sync::Arc};
2222

@@ -187,31 +187,31 @@ impl KeycloakAuthProvider {
187187
/// Helper to build JSON response for authorization server metadata with CORS.
188188
fn handle_authorization_server_metadata(
189189
response_str: String,
190-
) -> TransportServerResult<http::Response<GenericBody>> {
190+
) -> McpHttpResult<http::Response<GenericBody>> {
191191
let body = Full::new(Bytes::from(response_str))
192-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
192+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
193193
.boxed();
194194
http::Response::builder()
195195
.status(StatusCode::OK)
196196
.header(CONTENT_TYPE, "application/json")
197197
.body(body)
198-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
198+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
199199
}
200200

201201
/// Helper to build JSON response for protected resource metadata with permissive CORS.
202202
fn handle_protected_resource_metadata(
203203
response_str: String,
204-
) -> TransportServerResult<http::Response<GenericBody>> {
204+
) -> McpHttpResult<http::Response<GenericBody>> {
205205
use http_body_util::BodyExt;
206206

207207
let body = Full::new(Bytes::from(response_str))
208-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
208+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
209209
.boxed();
210210
http::Response::builder()
211211
.status(StatusCode::OK)
212212
.header(CONTENT_TYPE, "application/json")
213213
.body(body)
214-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
214+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
215215
}
216216
}
217217

@@ -227,12 +227,12 @@ impl AuthProvider for KeycloakAuthProvider {
227227
&self,
228228
request: http::Request<&str>,
229229
state: Arc<McpAppState>,
230-
) -> Result<http::Response<GenericBody>, TransportServerError> {
230+
) -> Result<http::Response<GenericBody>, McpHttpError> {
231231
let Some(endpoint) = self.endpoint_type(&request) else {
232232
return http::Response::builder()
233233
.status(StatusCode::NOT_FOUND)
234234
.body(GenericBody::empty())
235-
.map_err(|err| TransportServerError::HttpError(err.to_string()));
235+
.map_err(|err| McpHttpError::HttpError(err.to_string()));
236236
};
237237

238238
// return early if method is not allowed
@@ -243,7 +243,7 @@ impl AuthProvider for KeycloakAuthProvider {
243243
match endpoint {
244244
OauthEndpoint::AuthorizationServerMetadata => {
245245
let json_payload = serde_json::to_string(&self.auth_server_meta)
246-
.map_err(|err| TransportServerError::HttpError(err.to_string()))?;
246+
.map_err(|err| McpHttpError::HttpError(err.to_string()))?;
247247
let cors = &CorsMiddleware::default();
248248
cors.handle(
249249
request,
@@ -258,7 +258,7 @@ impl AuthProvider for KeycloakAuthProvider {
258258
}
259259
OauthEndpoint::ProtectedResourceMetadata => {
260260
let json_payload = serde_json::to_string(&self.protected_resource_meta)
261-
.map_err(|err| TransportServerError::HttpError(err.to_string()))?;
261+
.map_err(|err| McpHttpError::HttpError(err.to_string()))?;
262262

263263
let cors = &CorsMiddleware::default();
264264
cors.handle(

‎crates/rust-mcp-extra/src/auth_provider/scalekit.rs‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -12,11 +12,11 @@ use rust_mcp_sdk::{
1212
OauthProtectedResourceMetadata, OauthTokenVerifier,
1313
},
1414
error::McpSdkError,
15-
mcp_http::{middleware::CorsMiddleware, GenericBody, GenericBodyExt, Middleware},
16-
mcp_server::{
17-
error::{TransportServerError, TransportServerResult},
18-
join_url, McpAppState,
15+
mcp_http::{
16+
middleware::CorsMiddleware, GenericBody, GenericBodyExt, McpAppState, McpHttpError,
17+
McpHttpResult, Middleware,
1918
},
19+
mcp_server::join_url,
2020
};
2121
use std::{collections::HashMap, sync::Arc, vec};
2222
use url::Url;
@@ -171,31 +171,31 @@ impl ScalekitAuthProvider {
171171
/// Helper to build JSON response for authorization server metadata with CORS.
172172
fn handle_authorization_server_metadata(
173173
response_str: String,
174-
) -> TransportServerResult<http::Response<GenericBody>> {
174+
) -> McpHttpResult<http::Response<GenericBody>> {
175175
let body = Full::new(Bytes::from(response_str))
176-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
176+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
177177
.boxed();
178178
http::Response::builder()
179179
.status(StatusCode::OK)
180180
.header(CONTENT_TYPE, "application/json")
181181
.body(body)
182-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
182+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
183183
}
184184

185185
/// Helper to build JSON response for protected resource metadata with permissive CORS.
186186
fn handle_protected_resource_metadata(
187187
response_str: String,
188-
) -> TransportServerResult<http::Response<GenericBody>> {
188+
) -> McpHttpResult<http::Response<GenericBody>> {
189189
use http_body_util::BodyExt;
190190

191191
let body = Full::new(Bytes::from(response_str))
192-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
192+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
193193
.boxed();
194194
http::Response::builder()
195195
.status(StatusCode::OK)
196196
.header(CONTENT_TYPE, "application/json")
197197
.body(body)
198-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
198+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
199199
}
200200
}
201201

@@ -211,12 +211,12 @@ impl AuthProvider for ScalekitAuthProvider {
211211
&self,
212212
request: http::Request<&str>,
213213
state: Arc<McpAppState>,
214-
) -> Result<http::Response<GenericBody>, TransportServerError> {
214+
) -> Result<http::Response<GenericBody>, McpHttpError> {
215215
let Some(endpoint) = self.endpoint_type(&request) else {
216216
return http::Response::builder()
217217
.status(StatusCode::NOT_FOUND)
218218
.body(GenericBody::empty())
219-
.map_err(|err| TransportServerError::HttpError(err.to_string()));
219+
.map_err(|err| McpHttpError::HttpError(err.to_string()));
220220
};
221221

222222
// return early if method is not allowed
@@ -227,7 +227,7 @@ impl AuthProvider for ScalekitAuthProvider {
227227
match endpoint {
228228
OauthEndpoint::AuthorizationServerMetadata => {
229229
let json_payload = serde_json::to_string(&self.auth_server_meta)
230-
.map_err(|err| TransportServerError::HttpError(err.to_string()))?;
230+
.map_err(|err| McpHttpError::HttpError(err.to_string()))?;
231231
let cors = &CorsMiddleware::default();
232232
cors.handle(
233233
request,
@@ -242,7 +242,7 @@ impl AuthProvider for ScalekitAuthProvider {
242242
}
243243
OauthEndpoint::ProtectedResourceMetadata => {
244244
let json_payload = serde_json::to_string(&self.protected_resource_meta)
245-
.map_err(|err| TransportServerError::HttpError(err.to_string()))?;
245+
.map_err(|err| McpHttpError::HttpError(err.to_string()))?;
246246
let cors = &CorsMiddleware::default();
247247
cors.handle(
248248
request,

‎crates/rust-mcp-extra/src/auth_provider/work_os.rs‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -53,11 +53,11 @@ use rust_mcp_sdk::{
5353
OauthProtectedResourceMetadata, OauthTokenVerifier,
5454
},
5555
error::McpSdkError,
56-
mcp_http::{middleware::CorsMiddleware, GenericBody, GenericBodyExt, Middleware},
57-
mcp_server::{
58-
error::{TransportServerError, TransportServerResult},
59-
join_url, McpAppState,
56+
mcp_http::{
57+
middleware::CorsMiddleware, GenericBody, GenericBodyExt, McpAppState, McpHttpError,
58+
McpHttpResult, Middleware,
6059
},
60+
mcp_server::join_url,
6161
};
6262
use std::{collections::HashMap, sync::Arc, vec};
6363

@@ -170,31 +170,31 @@ impl WorkOsAuthProvider {
170170
/// Helper to build JSON response for authorization server metadata with CORS.
171171
fn handle_authorization_server_metadata(
172172
response_str: String,
173-
) -> TransportServerResult<http::Response<GenericBody>> {
173+
) -> McpHttpResult<http::Response<GenericBody>> {
174174
let body = Full::new(Bytes::from(response_str))
175-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
175+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
176176
.boxed();
177177
http::Response::builder()
178178
.status(StatusCode::OK)
179179
.header(CONTENT_TYPE, "application/json")
180180
.body(body)
181-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
181+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
182182
}
183183

184184
/// Helper to build JSON response for protected resource metadata with permissive CORS.
185185
fn handle_protected_resource_metadata(
186186
response_str: String,
187-
) -> TransportServerResult<http::Response<GenericBody>> {
187+
) -> McpHttpResult<http::Response<GenericBody>> {
188188
use http_body_util::BodyExt;
189189

190190
let body = Full::new(Bytes::from(response_str))
191-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
191+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
192192
.boxed();
193193
http::Response::builder()
194194
.status(StatusCode::OK)
195195
.header(CONTENT_TYPE, "application/json")
196196
.body(body)
197-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
197+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
198198
}
199199
}
200200

@@ -210,12 +210,12 @@ impl AuthProvider for WorkOsAuthProvider {
210210
&self,
211211
request: http::Request<&str>,
212212
state: Arc<McpAppState>,
213-
) -> Result<http::Response<GenericBody>, TransportServerError> {
213+
) -> Result<http::Response<GenericBody>, McpHttpError> {
214214
let Some(endpoint) = self.endpoint_type(&request) else {
215215
return http::Response::builder()
216216
.status(StatusCode::NOT_FOUND)
217217
.body(GenericBody::empty())
218-
.map_err(|err| TransportServerError::HttpError(err.to_string()));
218+
.map_err(|err| McpHttpError::HttpError(err.to_string()));
219219
};
220220

221221
// return early if method is not allowed
@@ -226,7 +226,7 @@ impl AuthProvider for WorkOsAuthProvider {
226226
match endpoint {
227227
OauthEndpoint::AuthorizationServerMetadata => {
228228
let json_payload = serde_json::to_string(&self.auth_server_meta)
229-
.map_err(|err| TransportServerError::HttpError(err.to_string()))?;
229+
.map_err(|err| McpHttpError::HttpError(err.to_string()))?;
230230
let cors = &CorsMiddleware::default();
231231
cors.handle(
232232
request,
@@ -241,7 +241,7 @@ impl AuthProvider for WorkOsAuthProvider {
241241
}
242242
OauthEndpoint::ProtectedResourceMetadata => {
243243
let json_payload = serde_json::to_string(&self.protected_resource_meta)
244-
.map_err(|err| TransportServerError::HttpError(err.to_string()))?;
244+
.map_err(|err| McpHttpError::HttpError(err.to_string()))?;
245245
let cors = &CorsMiddleware::default();
246246
cors.handle(
247247
request,

‎crates/rust-mcp-sdk/src/auth/auth_provider.rs‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,7 @@
11
mod remote_auth_provider;
22
use crate::auth::OauthEndpoint;
33
use crate::auth::{AuthInfo, AuthenticationError};
4-
use crate::mcp_http::{GenericBody, GenericBodyExt, McpAppState};
5-
use crate::mcp_server::error::TransportServerError;
4+
use crate::mcp_http::{GenericBody, GenericBodyExt, McpAppState, McpHttpError};
65
use async_trait::async_trait;
76
use http::Method;
87
pub use remote_auth_provider::*;
@@ -37,7 +36,7 @@ pub trait AuthProvider: Send + Sync {
3736
&self,
3837
request: http::Request<&str>,
3938
state: Arc<McpAppState>,
40-
) -> Result<http::Response<GenericBody>, TransportServerError>;
39+
) -> Result<http::Response<GenericBody>, McpHttpError>;
4140

4241
/// Returns the `OauthEndpoint` associated with the given request path.
4342
///

‎crates/rust-mcp-sdk/src/auth/auth_provider/remote_auth_provider.rs‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -5,9 +5,9 @@ use crate::{
55
OauthTokenVerifier, WELL_KNOWN_OAUTH_AUTHORIZATION_SERVER,
66
},
77
mcp_http::{
8-
middleware::CorsMiddleware, url_base, GenericBody, GenericBodyExt, McpAppState, Middleware,
8+
middleware::CorsMiddleware, url_base, GenericBody, GenericBodyExt, McpAppState,
9+
McpHttpError, McpHttpResult, Middleware,
910
},
10-
mcp_server::error::{TransportServerError, TransportServerResult},
1111
};
1212
use async_trait::async_trait;
1313
use bytes::Bytes;
@@ -87,30 +87,30 @@ impl RemoteAuthProvider {
8787

8888
fn handle_authorization_server_metadata(
8989
response_str: String,
90-
) -> TransportServerResult<http::Response<GenericBody>> {
90+
) -> McpHttpResult<http::Response<GenericBody>> {
9191
let body = Full::new(Bytes::from(response_str))
92-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
92+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
9393
.boxed();
9494
http::Response::builder()
9595
.status(StatusCode::OK)
9696
.header(CONTENT_TYPE, "application/json")
9797
.body(body)
98-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
98+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
9999
}
100100

101101
fn handle_protected_resource_metadata(
102102
response_str: String,
103-
) -> TransportServerResult<http::Response<GenericBody>> {
103+
) -> McpHttpResult<http::Response<GenericBody>> {
104104
use http_body_util::BodyExt;
105105

106106
let body = Full::new(Bytes::from(response_str))
107-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
107+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
108108
.boxed();
109109
http::Response::builder()
110110
.status(StatusCode::OK)
111111
.header(CONTENT_TYPE, "application/json")
112112
.body(body)
113-
.map_err(|err| TransportServerError::HttpError(err.to_string()))
113+
.map_err(|err| McpHttpError::HttpError(err.to_string()))
114114
}
115115
}
116116

@@ -132,12 +132,12 @@ impl AuthProvider for RemoteAuthProvider {
132132
&self,
133133
request: http::Request<&str>,
134134
state: Arc<McpAppState>,
135-
) -> Result<http::Response<GenericBody>, TransportServerError> {
135+
) -> Result<http::Response<GenericBody>, McpHttpError> {
136136
let Some(endpoint) = self.endpoint_type(&request) else {
137137
return http::Response::builder()
138138
.status(StatusCode::NOT_FOUND)
139139
.body(GenericBody::empty())
140-
.map_err(|err| TransportServerError::HttpError(err.to_string()));
140+
.map_err(|err| McpHttpError::HttpError(err.to_string()));
141141
};
142142

143143
// return early if method is not allowed
@@ -148,7 +148,7 @@ impl AuthProvider for RemoteAuthProvider {
148148
match endpoint {
149149
OauthEndpoint::AuthorizationServerMetadata => {
150150
let json_payload = serde_json::to_string(&self.auth_server_meta)
151-
.map_err(|err| TransportServerError::HttpError(err.to_string()))?;
151+
.map_err(|err| McpHttpError::HttpError(err.to_string()))?;
152152
let cors = &CorsMiddleware::default();
153153
cors.handle(
154154
request,
@@ -163,7 +163,7 @@ impl AuthProvider for RemoteAuthProvider {
163163
}
164164
OauthEndpoint::ProtectedResourceMetadata => {
165165
let json_payload = serde_json::to_string(&self.protected_resource_meta)
166-
.map_err(|err| TransportServerError::HttpError(err.to_string()))?;
166+
.map_err(|err| McpHttpError::HttpError(err.to_string()))?;
167167

168168
let cors = &CorsMiddleware::default();
169169
cors.handle(

0 commit comments

Comments
 (0)