Merge pull request #121 from jackh726/update

Update rmcp to 1.0.0-alpha

Author: nikomatsakis

Cargo.toml

@@ -39,7 +39,7 @@ tracing-appender = "0.2"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 
 # MCP SDK
-rmcp = { version = "0.12.0", features = ["server", "transport-io", "schemars"] }
+rmcp = { version = "1.0.0-alpha", features = ["server", "transport-io", "schemars"] }
 
 # CLI parsing
 clap = { version = "4.5", features = ["derive"] }

src/elizacp/src/eliza.rs

@@ -2473,8 +2473,7 @@ mod tests {
 
         // Tokio blocking
         let r = eliza.respond("my tokio code is blocking");
-        expect!["Tokio giveth, and Tokio taketh away."]
-            .assert_eq(&r);
+        expect!["Tokio giveth, and Tokio taketh away."].assert_eq(&r);
     }
 }
 

src/elizacp/src/lib.rs

@@ -9,7 +9,7 @@ use sacp::schema::{
     PromptRequest, PromptResponse, SessionId, SessionNotification, SessionUpdate, StopReason,
     TextContent,
 };
-use sacp::{Agent, Client, ConnectionTo, Responder, ConnectTo};
+use sacp::{Agent, Client, ConnectTo, ConnectionTo, Responder};
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 
@@ -294,7 +294,7 @@ impl ElizaAgent {
         tool_name: &str,
         params_json: &str,
     ) -> Result<String> {
-        use rmcp::model::CallToolRequestParam;
+        use rmcp::model::CallToolRequestParams;
 
         // Parse params JSON
         let params = serde_json::from_str::<serde_json::Value>(params_json)
@@ -308,10 +308,10 @@ impl ElizaAgent {
 
             // Call the tool
             let tool_result = mcp_client
-                .call_tool(CallToolRequestParam {
-                    name: tool_name.into(),
-                    arguments: params_obj,
-                })
+                .call_tool(
+                    CallToolRequestParams::new(tool_name)
+                        .with_arguments(params_obj.unwrap_or_default()),
+                )
                 .await?;
 
             tracing::debug!("Tool call result: {:?}", tool_result);
@@ -368,7 +368,8 @@ fn parse_tool_call(input: &str) -> Option<(String, String, String)> {
 
 impl ConnectTo<Client> for ElizaAgent {
     async fn connect_to(self, client: impl ConnectTo<Agent>) -> Result<(), sacp::Error> {
-        Agent.builder()
+        Agent
+            .builder()
             .name("elizacp")
             .on_receive_request(
                 async |initialize: InitializeRequest, responder, _cx| {

src/elizacp/tests/mcp_tool_invocation.rs

@@ -39,7 +39,8 @@ async fn test_elizacp_mcp_tool_call() -> Result<(), sacp::Error> {
     // Create channel to collect session notifications
     let (notification_tx, mut notification_rx) = futures::channel::mpsc::unbounded();
 
-    Client.builder()
+    Client
+        .builder()
         .name("test-client")
         .on_receive_notification(
             {
@@ -63,9 +64,10 @@ async fn test_elizacp_mcp_tool_call() -> Result<(), sacp::Error> {
         })
         .connect_with(transport, async |connection_to_client| {
             // Initialize
-            let _init_response =
-                recv(connection_to_client.send_request(InitializeRequest::new(ProtocolVersion::LATEST)))
-                    .await?;
+            let _init_response = recv(
+                connection_to_client.send_request(InitializeRequest::new(ProtocolVersion::LATEST)),
+            )
+            .await?;
 
             // Create session with an MCP server
             // Use the mcp-echo-server from sacp-test (pre-built binary)

src/sacp-conductor/src/conductor/mcp_bridge/actor.rs

@@ -1,5 +1,5 @@
 use futures::{SinkExt as _, StreamExt as _, channel::mpsc};
-use sacp::{DynConnectTo, Dispatch, ConnectTo, role::mcp, schema::McpDisconnectNotification};
+use sacp::{ConnectTo, Dispatch, DynConnectTo, role::mcp, schema::McpDisconnectNotification};
 use tracing::info;
 
 use crate::conductor::ConductorMessage;
@@ -41,7 +41,8 @@ impl McpBridgeConnectionActor {
             to_mcp_client_rx,
         } = self;
 
-        let result = mcp::Client.builder()
+        let result = mcp::Client
+            .builder()
             .name(format!("mpc-client-to-conductor({connection_id})"))
             // When we receive a message from the MCP client, forward it to the conductor
             .on_receive_dispatch(

src/sacp-conductor/src/snoop.rs

@@ -1,6 +1,6 @@
 use futures::StreamExt;
 use futures_concurrency::future::TryJoin;
-use sacp::{Channel, DynConnectTo, Role, ConnectTo, jsonrpcmsg};
+use sacp::{Channel, ConnectTo, DynConnectTo, Role, jsonrpcmsg};
 
 pub struct SnooperComponent<R: Role> {
     base_component: DynConnectTo<R>,
@@ -29,7 +29,10 @@ impl<R: Role> SnooperComponent<R> {
 }
 
 impl<R: Role> ConnectTo<R> for SnooperComponent<R> {
-    async fn connect_to(mut self, client: impl ConnectTo<R::Counterpart>) -> Result<(), sacp::Error> {
+    async fn connect_to(
+        mut self,
+        client: impl ConnectTo<R::Counterpart>,
+    ) -> Result<(), sacp::Error> {
         let (client_a, mut client_b) = Channel::duplex();
 
         let client_future = client.connect_to(client_a);

src/sacp-conductor/tests/empty_conductor_eliza.rs

@@ -6,7 +6,7 @@
 //! 3. Messages flow correctly through the empty conductor to eliza
 //! 4. The full chain works end-to-end
 
-use sacp::{Agent, Client, Conductor, Proxy, ConnectTo};
+use sacp::{Agent, Client, Conductor, ConnectTo, Proxy};
 use sacp_conductor::{ConductorImpl, ProxiesAndAgent};
 use tokio::io::duplex;
 use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt};

src/sacp-conductor/tests/initialization_sequence.rs

@@ -10,7 +10,7 @@ use sacp::schema::{
     AgentCapabilities, InitializeProxyRequest, InitializeRequest, InitializeResponse,
     ProtocolVersion,
 };
-use sacp::{Agent, Client, Conductor, DynConnectTo, Proxy, ConnectTo};
+use sacp::{Agent, Client, Conductor, ConnectTo, DynConnectTo, Proxy};
 use sacp_conductor::{ConductorImpl, ProxiesAndAgent};
 use std::sync::Arc;
 use std::sync::Mutex;
@@ -73,7 +73,8 @@ impl ConnectTo<Conductor> for InitComponent {
         let config = self.config;
         let config2 = Arc::clone(&config);
 
-        Proxy.builder()
+        Proxy
+            .builder()
             .name("init-component")
             // Handle InitializeProxyRequest (we're a proxy)
             .on_receive_request_from(
@@ -121,7 +122,8 @@ async fn run_test_with_components(
 
     let transport = sacp::ByteStreams::new(editor_out.compat_write(), editor_in.compat());
 
-    sacp::Client.builder()
+    sacp::Client
+        .builder()
         .name("editor-to-connector")
         .with_spawned(|_cx| async move {
             ConductorImpl::new_agent(
@@ -144,8 +146,10 @@ async fn test_single_component_gets_initialize_request() -> Result<(), sacp::Err
     // Single component (agent) should receive InitializeRequest - we use ElizaAgent
     // which properly handles InitializeRequest
     run_test_with_components(vec![], async |connection_to_editor| {
-        let init_response =
-            recv(connection_to_editor.send_request(InitializeRequest::new(ProtocolVersion::LATEST))).await;
+        let init_response = recv(
+            connection_to_editor.send_request(InitializeRequest::new(ProtocolVersion::LATEST)),
+        )
+        .await;
 
         assert!(
             init_response.is_ok(),
@@ -166,18 +170,23 @@ async fn test_two_components_proxy_gets_initialize_proxy() -> Result<(), sacp::E
     // Second component (agent, ElizaAgent) gets InitializeRequest
     let component1 = InitConfig::new();
 
-    run_test_with_components(vec![InitComponent::new(&component1)], async |connection_to_editor| {
-        let init_response =
-            recv(connection_to_editor.send_request(InitializeRequest::new(ProtocolVersion::LATEST))).await;
+    run_test_with_components(
+        vec![InitComponent::new(&component1)],
+        async |connection_to_editor| {
+            let init_response = recv(
+                connection_to_editor.send_request(InitializeRequest::new(ProtocolVersion::LATEST)),
+            )
+            .await;
 
-        assert!(
-            init_response.is_ok(),
-            "Initialize should succeed: {:?}",
-            init_response
-        );
+            assert!(
+                init_response.is_ok(),
+                "Initialize should succeed: {:?}",
+                init_response
+            );
 
-        Ok::<(), sacp::Error>(())
-    })
+            Ok::<(), sacp::Error>(())
+        },
+    )
     .await?;
 
     // First component (proxy) should receive InitializeProxyRequest
@@ -205,8 +214,10 @@ async fn test_three_components_all_proxies_get_initialize_proxy() -> Result<(),
             InitComponent::new(&component2),
         ],
         async |connection_to_editor| {
-            let init_response =
-                recv(connection_to_editor.send_request(InitializeRequest::new(ProtocolVersion::LATEST))).await;
+            let init_response = recv(
+                connection_to_editor.send_request(InitializeRequest::new(ProtocolVersion::LATEST)),
+            )
+            .await;
 
             assert!(
                 init_response.is_ok(),
@@ -241,11 +252,9 @@ async fn test_three_components_all_proxies_get_initialize_proxy() -> Result<(),
 struct BadProxy;
 
 impl ConnectTo<Conductor> for BadProxy {
-    async fn connect_to(
-        self,
-        client: impl ConnectTo<Proxy>,
-    ) -> Result<(), sacp::Error> {
-        Proxy.builder()
+    async fn connect_to(self, client: impl ConnectTo<Proxy>) -> Result<(), sacp::Error> {
+        Proxy
+            .builder()
             .name("bad-proxy")
             .on_receive_request_from(
                 Client,
@@ -275,7 +284,8 @@ async fn run_bad_proxy_test(
 
     let transport = sacp::ByteStreams::new(editor_out.compat_write(), editor_in.compat());
 
-    sacp::Client.builder()
+    sacp::Client
+        .builder()
         .name("editor-to-connector")
         .with_spawned(|_cx| async move {
             ConductorImpl::new_agent(
@@ -301,8 +311,10 @@ async fn test_conductor_rejects_initialize_proxy_forwarded_to_agent() -> Result<
         vec![DynConnectTo::new(BadProxy)],
         DynConnectTo::new(ElizaAgent::new(true)),
         async |connection_to_editor| {
-            let init_response =
-                recv(connection_to_editor.send_request(InitializeRequest::new(ProtocolVersion::LATEST))).await;
+            let init_response = recv(
+                connection_to_editor.send_request(InitializeRequest::new(ProtocolVersion::LATEST)),
+            )
+            .await;
 
             if let Err(err) = init_response {
                 assert!(
@@ -342,8 +354,10 @@ async fn test_conductor_rejects_initialize_proxy_forwarded_to_proxy() -> Result<
         ],
         DynConnectTo::new(ElizaAgent::new(true)), // Agent
         async |connection_to_editor| {
-            let init_response =
-                recv(connection_to_editor.send_request(InitializeRequest::new(ProtocolVersion::LATEST))).await;
+            let init_response = recv(
+                connection_to_editor.send_request(InitializeRequest::new(ProtocolVersion::LATEST)),
+            )
+            .await;
 
             // The error may come through recv() or bubble up through the test harness
             if let Err(err) = init_response {