use rmcp::{ErrorData, RoleServer, ServerHandler, model::*, service::RequestContext};
use crate::{AppRouter, RegistrationError};
pub struct AppServer<S> {
state: S,
router: AppRouter<S>,
info: ServerConfig,
}
impl<S: Send + Sync + 'static> AppServer<S> {
pub fn new(state: S, router: AppRouter<S>) -> Result<Self, RegistrationError> {
router.validate()?;
let mut info = ServerConfig::default();
router.declare_capabilities(&mut info.capabilities);
Ok(Self {
state,
router,
info,
})
}
pub fn with_server_info(mut self, implementation: Implementation) -> Self {
self.info.server_info = implementation;
self
}
pub fn with_instructions(mut self, instructions: impl Into<String>) -> Self {
self.info.instructions = Some(instructions.into());
self
}
pub fn state(&self) -> &S {
&self.state
}
pub fn router(&self) -> &AppRouter<S> {
&self.router
}
}
impl<S: Send + Sync + 'static> ServerHandler for AppServer<S> {
fn get_info(&self) -> ServerConfig {
self.info.clone()
}
fn get_tool(&self, name: &str) -> Option<Tool> {
self.router.get_tool(name)
}
async fn list_tools(
&self,
request: Option<PaginatedRequestParams>,
_: RequestContext<RoleServer>,
) -> Result<ListToolsResult, ErrorData> {
self.router.list_tools(request)
}
async fn call_tool(
&self,
request: CallToolRequestParams,
context: RequestContext<RoleServer>,
) -> Result<CallToolResponse, ErrorData> {
self.router.call_tool(&self.state, request, context).await
}
async fn list_resources(
&self,
request: Option<PaginatedRequestParams>,
_: RequestContext<RoleServer>,
) -> Result<ListResourcesResult, ErrorData> {
self.router.list_resources(request)
}
async fn read_resource(
&self,
request: ReadResourceRequestParams,
context: RequestContext<RoleServer>,
) -> Result<ReadResourceResponse, ErrorData> {
self.router
.read_resource(&self.state, request, context)
.await
}
}