Fix TODOs now that new features are available (#107)

Author: ia0

cli/CHANGELOG.md

@@ -22,6 +22,7 @@
 
 ### Patch
 
+- Remove `rmcp::tool` work-around by using `local` attribute
 - Fix clippy lints
 - Update dependencies
 - Support the new internal message timestamp logic

cli/Cargo.lock

@@ -30,7 +30,7 @@ opener = "0.7.2"
 platform-info = "2.0.5"
 rand = "0.9.3"
 reqwest = { version = "0.12.15", features = ["json"] }
-rmcp = "0.8.2"
+rmcp = "1.4.0"
 schemars = "1.0.4"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = { version = "1.0.140", features = ["preserve_order"] }
@@ -45,8 +45,6 @@ uuid = { version = "1.16.0", features = ["v4"] }
 inherits = "release"
 
 [lints]
-# TODO(https://github.com/rust-lang/rust/issues/53667): Remove when stable.
-clippy.collapsible-if = "allow"
 clippy.mod-module-files = "warn"
 clippy.unit-arg = "allow"
 rust.elided-lifetimes-in-paths = "warn"

cli/Cargo.toml

@@ -323,12 +323,12 @@ fn display_json_object(
 ) {
     for (key, val) in map {
         write!(out, "{}:", key.bold().color(color)).unwrap();
-        if let Some(val) = val.as_str() {
-            if val.find('\n').is_some_and(|i| i + 1 < val.len()) {
-                write!(out, "\n{}", val.color(color)).unwrap();
-                ensure_newline(val, out);
-                continue;
-            }
+        if let Some(val) = val.as_str()
+            && val.find('\n').is_some_and(|i| i + 1 < val.len())
+        {
+            write!(out, "\n{}", val.color(color)).unwrap();
+            ensure_newline(val, out);
+            continue;
         }
         writeln!(out, " {}", serde_json::to_string(val).unwrap().color(color)).unwrap();
     }

cli/src/cli/interact.rs

@@ -307,14 +307,13 @@ fn quote(mut word: &str) -> Cow<'_, str> {
         return word.into();
     };
     let mut quoted = String::new();
-    if word.starts_with("--") {
-        if let Some(eq) = word.find('=') {
-            if eq < pos {
-                let (prefix, suffix) = word.split_at(eq + 1);
-                quoted = prefix.to_string();
-                word = suffix;
-            }
-        }
+    if word.starts_with("--")
+        && let Some(eq) = word.find('=')
+        && eq < pos
+    {
+        let (prefix, suffix) = word.split_at(eq + 1);
+        quoted = prefix.to_string();
+        word = suffix;
     }
     quoted.push('\'');
     for c in word.chars() {

cli/src/cli/interact/cmds.rs

@@ -26,9 +26,9 @@ use crate::config;
 use crate::tool::Tools;
 
 pub fn list(tools: &mut Tools) {
-    tools.push(_spawn_tool_attr(), spawn);
-    tools.push(_interact_tool_attr(), interact);
-    tools.push(_kill_tool_attr(), kill);
+    tools.push(spawn_tool_attr(), spawn);
+    tools.push(interact_tool_attr(), interact);
+    tools.push(kill_tool_attr(), kill);
 }
 
 #[derive(Serialize, Deserialize, JsonSchema)]
@@ -47,12 +47,7 @@ pub struct SpawnRequest {
 ///
 /// This tool can be used together with `file_write` (setting `executable` to create an executable
 /// file) to execute a Python or shell script.
-#[rmcp::tool(name = "exec_spawn")]
-async fn _spawn(_: Parameters<SpawnRequest>) -> Result<Json<InteractResponse>, String> {
-    // TODO(https://github.com/modelcontextprotocol/rust-sdk/issues/495): Remove when fixed.
-    unreachable!()
-}
-
+#[rmcp::tool(local, name = "exec_spawn")]
 async fn spawn(params: Parameters<SpawnRequest>) -> Result<Json<InteractResponse>, String> {
     let SpawnRequest { program, arguments, interact: request } = params.0;
     let mut child = Command::new(program)
@@ -103,13 +98,8 @@ pub struct InteractResponse {
 /// The tool will listen for output until some amount of inactivity or some fixed deadline,
 /// whichever happens first. The tool will fail if the process outputs binary data that is not
 /// UTF-8.
-#[rmcp::tool(name = "exec_interact")]
-async fn _interact(_: Parameters<InteractRequest>) -> Result<Json<InteractResponse>, String> {
-    // TODO(https://github.com/modelcontextprotocol/rust-sdk/issues/495): Remove when fixed.
-    unreachable!()
-}
-
 #[allow(clippy::await_holding_lock)]
+#[rmcp::tool(local, name = "exec_interact")]
 async fn interact(params: Parameters<InteractRequest>) -> Result<Json<InteractResponse>, String> {
     let InteractRequest { stdin, close_stdin } = params.0;
     let mut state = STATE.lock().unwrap();
@@ -178,12 +168,8 @@ async fn interact(params: Parameters<InteractRequest>) -> Result<Json<InteractRe
 pub struct KillRequest {}
 
 /// Kills an running process.
-#[rmcp::tool(name = "exec_kill", annotations(destructive_hint = false))]
-async fn _kill(_: Parameters<KillRequest>) -> Result<Json<String>, String> {
-    unreachable!()
-}
-
 #[allow(clippy::await_holding_lock)]
+#[rmcp::tool(name = "exec_kill", annotations(destructive_hint = false))]
 async fn kill(params: Parameters<KillRequest>) -> Result<Json<String>, String> {
     let KillRequest {} = params.0;
     let Some(mut running) = STATE.lock().unwrap().take() else {

cli/src/tool/exec.rs

@@ -27,7 +27,7 @@ use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use crate::tool::Tools;
 
 pub fn list(tools: &mut Tools) {
-    tools.push(_list_tool_attr(), _list);
+    tools.push(flist_tool_attr(), flist);
     tools.push(read_tool_attr(), read);
     tools.push(write_tool_attr(), write);
     tools.push(sha256_tool_attr(), sha256);
@@ -47,7 +47,7 @@ pub struct ListResponse {
 ///
 /// In the response, directories are suffixed with a slash like `bin/`.
 #[rmcp::tool(name = "file_list", annotations(read_only_hint = true))]
-async fn _list(params: Parameters<ListRequest>) -> Result<Json<ListResponse>, String> {
+async fn flist(params: Parameters<ListRequest>) -> Result<Json<ListResponse>, String> {
     let ListRequest { path } = params.0;
     let mut names = Vec::new();
     let mut entries = tokio::fs::read_dir(path).await.map_err(|e| e.to_string())?;

cli/src/tool/file.rs

@@ -25,9 +25,9 @@ use crate::config;
 use crate::tool::Tools;
 
 pub fn list(tools: &mut Tools) {
-    tools.push(_connect_tool_attr(), connect);
-    tools.push(_interact_tool_attr(), interact);
-    tools.push(_close_tool_attr(), close);
+    tools.push(connect_tool_attr(), connect);
+    tools.push(interact_tool_attr(), interact);
+    tools.push(close_tool_attr(), close);
 }
 
 #[derive(Serialize, Deserialize, JsonSchema)]
@@ -42,12 +42,7 @@ pub struct ConnectRequest {
 /// To interact with the connection, use the `net_tcp_interact` tool. To close the connection, use
 /// the `net_tcp_close` tool. The initial interaction is built-in by taking the same `input` field
 /// as `net_tcp_interact` and returning the same fields.
-#[rmcp::tool(name = "net_tcp_connect", annotations(destructive_hint = false))]
-async fn _connect(_: Parameters<ConnectRequest>) -> Result<Json<InteractResponse>, String> {
-    // TODO(https://github.com/modelcontextprotocol/rust-sdk/issues/495): Remove when fixed.
-    unreachable!()
-}
-
+#[rmcp::tool(local, name = "net_tcp_connect", annotations(destructive_hint = false))]
 async fn connect(params: Parameters<ConnectRequest>) -> Result<Json<InteractResponse>, String> {
     let ConnectRequest { host, port, input } = params.0;
     let stream = TcpStream::connect((host, port)).await.map_err(|e| e.to_string())?;
@@ -73,13 +68,8 @@ pub struct InteractResponse {
 ///
 /// The tool will listen until some amount of inactivity or some fixed deadline, whichever happens
 /// first. The tool will fail if the peer sends binary data that is not UTF-8.
-#[rmcp::tool(name = "net_tcp_interact", annotations(destructive_hint = false))]
-async fn _interact(_: Parameters<InteractRequest>) -> Result<Json<InteractResponse>, String> {
-    // TODO(https://github.com/modelcontextprotocol/rust-sdk/issues/495): Remove when fixed.
-    unreachable!()
-}
-
 #[allow(clippy::await_holding_lock)]
+#[rmcp::tool(local, name = "net_tcp_interact", annotations(destructive_hint = false))]
 async fn interact(params: Parameters<InteractRequest>) -> Result<Json<InteractResponse>, String> {
     let InteractRequest { input } = params.0;
     let mut state = STATE.lock().unwrap();
@@ -119,12 +109,8 @@ async fn interact(params: Parameters<InteractRequest>) -> Result<Json<InteractRe
 pub struct CloseRequest {}
 
 /// Closes an open TCP connection.
-#[rmcp::tool(name = "net_tcp_close", annotations(destructive_hint = false))]
-async fn _close(_: Parameters<CloseRequest>) -> Result<Json<String>, String> {
-    unreachable!()
-}
-
 #[allow(clippy::await_holding_lock)]
+#[rmcp::tool(name = "net_tcp_close", annotations(destructive_hint = false))]
 async fn close(params: Parameters<CloseRequest>) -> Result<Json<String>, String> {
     let CloseRequest {} = params.0;
     let Some(mut stream) = STATE.lock().unwrap().take() else {