docs: update MCP server documentation for new API

- Update module docs with new McpServer::builder() usage
- Add McpServerConnect trait documentation with example
- Add McpServer type docs explaining handler vs manual usage
- Add McpServerBuilder docs with tool registration examples
- Expand McpTool trait docs with full implementation example
- Fix describe_chain to return server name instead of todo!()
- Update sacp-rmcp to use McpServerConnect via RmcpServer wrapper

Author: nikomatsakis

src/sacp-conductor/tests/mcp_integration/proxy.rs

@@ -2,7 +2,7 @@
 
 use sacp::Component;
 use sacp::ProxyToConductor;
-use sacp::mcp_server::{McpServer, McpServiceRegistry};
+use sacp::mcp_server::{McpServerConnect, McpServiceRegistry};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
@@ -24,7 +24,7 @@ struct ProxyComponent;
 
 impl Component for ProxyComponent {
     async fn serve(self, client: impl Component) -> Result<(), sacp::Error> {
-        let test_server = McpServer::new()
+        let test_server = McpServerConnect::new()
             .instructions("A simple test MCP server with an echo tool")
             .tool_fn(
                 "echo",

src/sacp-conductor/tests/test_session_id_in_mcp_tools.rs

@@ -10,7 +10,7 @@
 
 use sacp::Component;
 use sacp::ProxyToConductor;
-use sacp::mcp_server::{McpServer, McpServiceRegistry};
+use sacp::mcp_server::{McpServerConnect, McpServiceRegistry};
 use sacp_conductor::Conductor;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -30,7 +30,7 @@ struct EchoOutput {
 /// Create a proxy that provides an MCP server with a session_id echo tool
 fn create_echo_proxy() -> Result<sacp::DynComponent, sacp::Error> {
     // Create MCP server with an echo tool that returns the session_id
-    let mcp_server = McpServer::new()
+    let mcp_server = McpServerConnect::new()
         .instructions("Test MCP server with session_id echo tool")
         .tool_fn(
             "echo",

src/sacp-rmcp/src/lib.rs

@@ -1,70 +1,81 @@
 //! # sacp-rmcp - rmcp integration for SACP
 //!
 //! This crate provides integration between [rmcp](https://docs.rs/rmcp) MCP servers
-//! and the SACP proxy framework.
+//! and the SACP MCP server framework.
 //!
 //! ## Usage
 //!
-//! Add rmcp-based MCP servers to your proxy using the extension trait:
+//! Create an MCP server from an rmcp service:
 //!
 //! ```ignore
-//! use sacp::mcp_server::McpServiceRegistry;
-//! use sacp_rmcp::McpServiceRegistryRmcpExt;
+//! use sacp::mcp_server::McpServer;
+//! use sacp_rmcp::RmcpServer;
 //!
-//! let registry = McpServiceRegistry::new();
-//! registry.add_rmcp_server("my-server", || MyRmcpService::new())?;
+//! let server = McpServer::new(RmcpServer::new("my-server", || MyRmcpService::new()));
+//!
+//! // Use as a handler
+//! ProxyToConductor::builder()
+//!     .with_handler(server)
+//!     .serve(client)
+//!     .await?;
 //! ```
 
 use rmcp::ServiceExt;
-use sacp::Agent;
-use sacp::mcp_server::McpServiceRegistry;
-use sacp::{ByteStreams, Component, HasEndpoint, JrRole};
+use sacp::mcp_server::{McpContext, McpServerConnect};
+use sacp::{ByteStreams, Component, DynComponent, JrRole};
 use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt};
 
-/// Extension trait for adding rmcp-based MCP servers to a registry.
-pub trait McpServiceRegistryRmcpExt {
-    /// Return a version of the registry with MCP server implemented using the rmcp crate.
+/// Wrapper that implements [`McpServerConnect`] for rmcp services.
+///
+/// Use this to integrate existing rmcp-based MCP servers with the SACP framework.
+///
+/// # Example
+///
+/// ```ignore
+/// use sacp::mcp_server::McpServer;
+/// use sacp_rmcp::RmcpServer;
+///
+/// // Create an MCP server from an rmcp service factory
+/// let server = McpServer::new(RmcpServer::new("my-server", || MyRmcpService::new()));
+/// ```
+pub struct RmcpServer<F> {
+    name: String,
+    make_service: F,
+}
+
+impl<F> RmcpServer<F> {
+    /// Create a new rmcp server wrapper.
     ///
     /// # Parameters
     ///
-    /// - `name`: The name of the server.
-    /// - `make_service`: A function that creates the service (e.g., `YourService::new`).
-    ///
-    /// # Example
-    ///
-    /// ```ignore
-    /// registry.with_rmcp_server("my-server", || MyRmcpService::new())?
-    /// ```
-    fn with_rmcp_server<S>(
-        self,
-        name: impl ToString,
-        make_service: impl Fn() -> S + 'static + Send + Sync,
-    ) -> Result<Self, sacp::Error>
-    where
-        S: rmcp::Service<rmcp::RoleServer>,
-        Self: Sized;
+    /// - `name`: The name of the server (used in session responses).
+    /// - `make_service`: A function that creates a new rmcp service instance.
+    ///   This is called for each new connection.
+    pub fn new(name: impl ToString, make_service: F) -> Self {
+        Self {
+            name: name.to_string(),
+            make_service,
+        }
+    }
 }
 
-impl<Role: JrRole> McpServiceRegistryRmcpExt for McpServiceRegistry<Role>
+impl<Role, F, S> McpServerConnect<Role> for RmcpServer<F>
 where
-    Role: HasEndpoint<Agent>,
+    Role: JrRole,
+    F: Fn() -> S + Send + Sync + 'static,
+    S: rmcp::Service<rmcp::RoleServer>,
 {
-    fn with_rmcp_server<S>(
-        self,
-        name: impl ToString,
-        make_service: impl Fn() -> S + 'static + Send + Sync,
-    ) -> Result<Self, sacp::Error>
-    where
-        S: rmcp::Service<rmcp::RoleServer>,
-    {
-        self.with_custom_mcp_server(name, move |_| {
-            let service = make_service();
-            RmcpServerComponent { service }
-        })
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn connect(&self, _cx: McpContext<Role>) -> DynComponent {
+        let service = (self.make_service)();
+        DynComponent::new(RmcpServerComponent { service })
     }
 }
 
-/// Component wrapper for rmcp services
+/// Component wrapper for rmcp services.
 struct RmcpServerComponent<S> {
     service: S,
 }

src/sacp/src/jsonrpc.rs

@@ -30,6 +30,7 @@ pub use crate::jsonrpc::handlers::NullHandler;
 use crate::jsonrpc::handlers::{MessageHandler, NotificationHandler, RequestHandler};
 use crate::jsonrpc::outgoing_actor::{OutgoingMessageTx, send_raw_message};
 use crate::jsonrpc::task_actor::{PendingTask, Task, TaskTx};
+use crate::mcp_server::McpServer;
 use crate::role::{HasDefaultEndpoint, HasEndpoint, JrEndpoint, JrRole};
 use crate::{Agent, Client, Component};
 
@@ -569,10 +570,6 @@ impl<H: JrMessageHandler> JrConnectionBuilder<H> {
         self
     }
 
-    /// Returns a reference to the local role.
-
-    /// Returns a reference to the remote role.
-
     /// Merge another [`JrConnectionBuilder`] into this one.
     ///
     /// Prefer [`Self::on_receive_request`] or [`Self::on_receive_notification`].
@@ -893,10 +890,10 @@ impl<H: JrMessageHandler> JrConnectionBuilder<H> {
         self.with_handler(NotificationHandler::new(endpoint, <H::Role>::default(), op))
     }
 
-    /// Provide MCP servers to downstream successors.
+    /// In a proxy, add this MCP server to new sessions passing through the proxy.
     ///
     /// This adds a handler that intercepts `session/new` requests to include the
-    /// registered MCP servers.
+    /// registered MCP server.
     ///
     /// # Example
     ///
@@ -910,10 +907,10 @@ impl<H: JrMessageHandler> JrConnectionBuilder<H> {
     ///     .serve(connection)
     ///     .await?;
     /// ```
-    pub fn provide_mcp<Role: JrRole>(
+    pub fn with_mcp_server<Role: JrRole>(
         self,
-        registry: crate::mcp_server::McpServiceRegistry<Role>,
-    ) -> JrConnectionBuilder<ChainedHandler<H, crate::mcp_server::McpServiceRegistry<Role>>>
+        registry: McpServer<Role>,
+    ) -> JrConnectionBuilder<ChainedHandler<H, McpServer<Role>>>
     where
         H: JrMessageHandler<Role = Role>,
         Role: HasEndpoint<Client> + HasEndpoint<Agent>,

…rc/mcp_server/registry/active_session.rs src/sacp/src/mcp_server/active_session.rssrc/sacp/src/mcp_server/registry/active_session.rs renamed to src/sacp/src/mcp_server/active_session.rs src/sacp/src/mcp_server/registry/active_session.rs renamed to src/sacp/src/mcp_server/active_session.rs

@@ -3,8 +3,7 @@ use futures::{SinkExt, StreamExt};
 use fxhash::FxHashMap;
 
 use crate::mcp::{McpClientToServer, McpServerEnd};
-use crate::mcp_server::McpContext;
-use crate::mcp_server::registry::RegisteredMcpServer;
+use crate::mcp_server::{McpContext, McpServerConnect};
 use crate::schema::{
     McpConnectRequest, McpConnectResponse, McpDisconnectNotification, McpOverAcpMessage,
 };
@@ -19,7 +18,7 @@ use std::sync::Arc;
 /// This is added as a 'dynamic' handler to the connection context
 /// (see [`JrConnectionCx::add_dynamic_handler`]) and handles MCP-over-ACP messages
 /// with the appropriate ACP url.
-pub(super) struct McpServerSession<Role: JrRole>
+pub(super) struct McpActiveSession<Role: JrRole>
 where
     Role: HasEndpoint<Agent>,
 {
@@ -31,21 +30,21 @@ where
     acp_url: String,
 
     /// The MCP server we are managing
-    mcp_server: Arc<RegisteredMcpServer<Role>>,
+    mcp_connect: Arc<dyn McpServerConnect<Role>>,
 
     /// Active connections to MCP server tasks
     connections: FxHashMap<String, mpsc::Sender<MessageCx>>,
 }
 
-impl<Role: JrRole> McpServerSession<Role>
+impl<Role: JrRole> McpActiveSession<Role>
 where
     Role: HasEndpoint<Agent>,
 {
-    pub fn new(role: Role, acp_url: String, mcp_server: Arc<RegisteredMcpServer<Role>>) -> Self {
+    pub fn new(role: Role, acp_url: String, mcp_connect: Arc<dyn McpServerConnect<Role>>) -> Self {
         Self {
             role,
             acp_url,
-            mcp_server,
+            mcp_connect,
             connections: FxHashMap::default(),
         }
     }
@@ -113,7 +112,7 @@ where
         };
 
         // Get the MCP server component
-        let spawned_server = self.mcp_server.spawn.spawn(McpContext {
+        let spawned_server = self.mcp_connect.connect(McpContext {
             acp_url: request.acp_url.clone(),
             connection_cx: outer_cx.clone(),
         });
@@ -211,7 +210,7 @@ where
     }
 }
 
-impl<Role: JrRole> JrMessageHandlerSend for McpServerSession<Role>
+impl<Role: JrRole> JrMessageHandlerSend for McpActiveSession<Role>
 where
     Role: HasEndpoint<Agent>,
 {