refactor: update examples and tests to use new MCP server API

- Update with_mcp_server example to use McpServerExt::from_rmcp
- Update test_session_id_in_mcp_tools to use McpServer::builder
- Update mcp_integration proxy test for new API
- Refactor sacp-rmcp to use McpServerExt extension trait

Author: nikomatsakis

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

@@ -2,7 +2,7 @@
 
 use sacp::Component;
 use sacp::ProxyToConductor;
-use sacp::mcp_server::{McpServerConnect, McpServiceRegistry};
+use sacp::mcp_server::McpServer;
 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 = McpServerConnect::new()
+        let test_server = McpServer::builder("test")
             .instructions("A simple test MCP server with an echo tool")
             .tool_fn(
                 "echo",
@@ -35,11 +35,12 @@ impl Component for ProxyComponent {
                     })
                 },
                 |f, args, cx| Box::pin(f(args, cx)),
-            );
+            )
+            .build();
 
         ProxyToConductor::builder()
             .name("proxy-component")
-            .provide_mcp(McpServiceRegistry::default().with_mcp_server("test", test_server)?)
+            .with_mcp_server(test_server)
             .serve(client)
             .await
     }

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::{McpServerConnect, McpServiceRegistry};
+use sacp::mcp_server::McpServer;
 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 = McpServerConnect::new()
+    let mcp_server = McpServer::builder("echo_server".to_string())
         .instructions("Test MCP server with session_id echo tool")
         .tool_fn(
             "echo",
@@ -41,24 +41,22 @@ fn create_echo_proxy() -> Result<sacp::DynComponent, sacp::Error> {
                 })
             },
             |f, args, cx| Box::pin(f(args, cx)),
-        );
-
-    // Create registry with the server
-    let registry = McpServiceRegistry::default().with_mcp_server("echo_server", mcp_server)?;
+        )
+        .build();
 
     // Create proxy component
-    Ok(sacp::DynComponent::new(ProxyWithEchoServer { registry }))
+    Ok(sacp::DynComponent::new(ProxyWithEchoServer { mcp_server }))
 }
 
 struct ProxyWithEchoServer {
-    registry: McpServiceRegistry<ProxyToConductor>,
+    mcp_server: McpServer<ProxyToConductor>,
 }
 
 impl Component for ProxyWithEchoServer {
     async fn serve(self, client: impl Component) -> Result<(), sacp::Error> {
         ProxyToConductor::builder()
             .name("echo-proxy")
-            .provide_mcp(self.registry)
+            .with_handler(self.mcp_server)
             .serve(client)
             .await
     }

src/sacp-rmcp/examples/with_mcp_server.rs

@@ -15,8 +15,8 @@ use rmcp::{
     tool, tool_handler, tool_router,
 };
 use sacp::ProxyToConductor;
-use sacp::mcp_server::McpServiceRegistry;
-use sacp_rmcp::McpServiceRegistryRmcpExt;
+use sacp::mcp_server::McpServer;
+use sacp_rmcp::McpServerExt;
 use serde::{Deserialize, Serialize};
 use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt};
 
@@ -84,14 +84,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     tracing::info!("MCP server proxy starting");
 
+    // Create an MCP server from the rmcp service
+    let mcp_server = McpServer::from_rmcp("example", ExampleMcpServer::new);
+
     // Set up the proxy connection with our MCP server
     // ProxyToConductor already has proxy behavior built into its default_message_handler
     ProxyToConductor::builder()
         .name("mcp-server-proxy")
-        // Register the MCP server named "example"
-        .provide_mcp(
-            McpServiceRegistry::default().with_rmcp_server("example", ExampleMcpServer::new)?,
-        )
+        // Register the MCP server as a handler
+        .with_handler(mcp_server)
         // Start serving
         .connect_to(sacp::ByteStreams::new(
             tokio::io::stdout().compat_write(),

src/sacp-rmcp/src/lib.rs

@@ -5,13 +5,13 @@
 //!
 //! ## Usage
 //!
-//! Create an MCP server from an rmcp service:
+//! Create an MCP server from an rmcp service using the extension trait:
 //!
 //! ```ignore
 //! use sacp::mcp_server::McpServer;
-//! use sacp_rmcp::RmcpServer;
+//! use sacp_rmcp::McpServerExt;
 //!
-//! let server = McpServer::new(RmcpServer::new("my-server", || MyRmcpService::new()));
+//! let server = McpServer::from_rmcp("my-server", MyRmcpService::new);
 //!
 //! // Use as a handler
 //! ProxyToConductor::builder()
@@ -21,60 +21,56 @@
 //! ```
 
 use rmcp::ServiceExt;
-use sacp::mcp_server::{McpContext, McpServerConnect};
-use sacp::{ByteStreams, Component, DynComponent, JrRole};
+use sacp::mcp_server::{McpContext, McpServer, McpServerConnect};
+use sacp::{Agent, ByteStreams, Component, DynComponent, HasEndpoint, JrRole};
 use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt};
 
-/// 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.
+pub trait McpServerExt<Role: JrRole>
+where
+    Role: HasEndpoint<Agent>,
+{
+    /// Create an MCP server from something that implements the [`McpServerConnect`] trait.
     ///
-    /// # Parameters
+    /// # See also
     ///
-    /// - `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,
+    /// See [`Self::builder`] to construct MCP servers from Rust code.
+    fn from_rmcp<S>(
+        name: impl ToString,
+        new_fn: impl Fn() -> S + Send + Sync + 'static,
+    ) -> McpServer<Role>
+    where
+        S: rmcp::Service<rmcp::RoleServer>,
+    {
+        struct RmcpServer<F> {
+            name: String,
+            new_fn: F,
         }
-    }
-}
 
-impl<Role, F, S> McpServerConnect<Role> for RmcpServer<F>
-where
-    Role: JrRole,
-    F: Fn() -> S + Send + Sync + 'static,
-    S: rmcp::Service<rmcp::RoleServer>,
-{
-    fn name(&self) -> String {
-        self.name.clone()
-    }
+        impl<Role, F, S> McpServerConnect<Role> for RmcpServer<F>
+        where
+            Role: JrRole,
+            F: Fn() -> S + Send + Sync + 'static,
+            S: rmcp::Service<rmcp::RoleServer>,
+        {
+            fn name(&self) -> String {
+                self.name.clone()
+            }
 
-    fn connect(&self, _cx: McpContext<Role>) -> DynComponent {
-        let service = (self.make_service)();
-        DynComponent::new(RmcpServerComponent { service })
+            fn connect(&self, _cx: McpContext<Role>) -> DynComponent {
+                let service = (self.new_fn)();
+                DynComponent::new(RmcpServerComponent { service })
+            }
+        }
+
+        McpServer::new(RmcpServer {
+            name: name.to_string(),
+            new_fn,
+        })
     }
 }
 
+impl<Role: JrRole> McpServerExt<Role> for McpServer<Role> where Role: HasEndpoint<Agent> {}
+
 /// Component wrapper for rmcp services.
 struct RmcpServerComponent<S> {
     service: S,

src/sacp/src/mcp_server/server.rs

@@ -44,8 +44,8 @@ where
     Role: HasEndpoint<Agent>,
 {
     /// Create an empty server with no content.
-    pub fn builder(name: String) -> McpServerBuilder<Role> {
-        McpServerBuilder::new(name)
+    pub fn builder(name: impl ToString) -> McpServerBuilder<Role> {
+        McpServerBuilder::new(name.to_string())
     }
 
     /// Create an MCP server from something that implements the [`McpServerConnect`] trait.