Struct StreamableHttpService 

pub struct StreamableHttpService<S, M = LocalSessionManager> {
    pub config: StreamableHttpServerConfig,
    /* private fields */
}

Available on crate features transport-streamable-http-server-session and transport-streamable-http-server only.

Streamable Http Server

Extract information from raw http request

The http service will consume the request body, however the rest part will be remain and injected into crate::model::Extensions, which you can get from crate::service::RequestContext.

use mcpkit_rs::handler::server::tool::Extension;
use http::request::Parts;
async fn my_tool(Extension(parts): Extension<Parts>) {
    tracing::info!("http parts:{parts:?}")
}

Fields

config: StreamableHttpServerConfig

Implementations

impl<S, M> StreamableHttpService<S, M>

where S: Service<RoleServer> + Send + 'static, M: SessionManager,

pub fn new( service_factory: impl Fn() -> Result<S, Error> + Send + Sync + 'static, session_manager: Arc<M>, config: StreamableHttpServerConfig, ) -> Self

pub async fn handle<B>( &self, request: Request<B>, ) -> Response<BoxBody<Bytes, Infallible>>

where B: Body + Send + 'static, B::Error: Display,

Trait Implementations

impl<S, M> Clone for StreamableHttpService<S, M>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<RequestBody, S, M> Service<Request<RequestBody>> for StreamableHttpService<S, M>

where RequestBody: Body + Send + 'static, S: Service<RoleServer>, M: SessionManager, RequestBody::Error: Display, RequestBody::Data: Send + 'static,

type Response = Response<BoxBody<Bytes, Infallible>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<StreamableHttpService<S, M> as Service<Request<RequestBody>>>::Response, <StreamableHttpService<S, M> as Service<Request<RequestBody>>>::Error>> + Send>>

The future response value.

fn call(&mut self, req: Request<RequestBody>) -> Self::Future

Process the request and return the response asynchronously.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.