SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
MCP: explain when an unknown command id is actually an MCP tool name (#10678) (#10680)
Dahak Builds176c22acaa05
diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rsindex 39918e9886..23957f826d 100644--- a/crates/mcp/src/tests.rs+++ b/crates/mcp/src/tests.rs@@ -1271,6 +1271,77 @@ fn tool_unknown_command_errors_explain_packed_params() {assert!(body["failed"]["error"].as_str().unwrap().contains("command ids have no parameters; pass them in `params`"), "{body}");}+/// #10678: through direct `execute`, an unknown command id that is exactly a registered+/// MCP tool name gets the namespace hint instead of unrelated closest-command suggestions.+#[test]+fn tool_name_command_ids_get_namespace_hint_via_execute() {+ let mut s = server();+ for id in ["execute", "list_commands", "describe_command", "screenshot"] {+ let r = raw_tool(&mut s, "execute", json!({"command": id, "params": {}}));+ assert_eq!(r["result"]["isError"], true, "{r}");+ let text = r["result"]["content"][0]["text"].as_str().unwrap();+ assert!(text.starts_with(&format!("unknown command `{id}`")), "{text}");+ assert!(text.contains(&format!("`{id}` is an MCP tool, not an engine command id")), "{text}");+ assert!(text.contains("tools/list") && text.contains("list_commands"), "{text}");+ assert!(!text.contains("closest:"), "{text}");+ }+}++/// #10678: the direct `describe_command` hint inspects the requested `id`, not the outer+/// `engine.describe` command `exec` sees.+#[test]+fn tool_name_command_ids_get_namespace_hint_via_describe_command() {+ let mut s = server();+ for id in ["execute", "list_commands"] {+ let r = raw_tool(&mut s, "describe_command", json!({"id": id}));+ assert_eq!(r["result"]["isError"], true, "{r}");+ let text = r["result"]["content"][0]["text"].as_str().unwrap();+ assert!(text.starts_with(&format!("unknown command `{id}`")), "{text}");+ assert!(text.contains(&format!("`{id}` is an MCP tool, not an engine command id")), "{text}");+ assert!(!text.contains("engine.describe"), "{text}");+ }+ // Control: a valid engine command id still describes itself.+ let r = raw_tool(&mut s, "describe_command", json!({"id": "solid.box"}));+ assert_ne!(r["result"]["isError"], true, "{r}");+}++/// #10678: an engine-id typo keeps its closest-command suggestions; the tool-name hint is+/// only for exact registered tool names.+#[test]+fn engine_command_id_typo_still_gets_closest_suggestions() {+ let mut s = server();+ let r = raw_tool(&mut s, "execute", json!({"command": "solid.bxo"}));+ assert_eq!(r["result"]["isError"], true, "{r}");+ let text = r["result"]["content"][0]["text"].as_str().unwrap();+ assert!(text.contains("closest: `solid.box`"), "{text}");+ assert!(!text.contains("MCP tool"), "{text}");+}++/// #10678: a genuinely unknown id keeps the ordinary unknown-command error on both paths.+#[test]+fn genuinely_unknown_command_id_keeps_the_ordinary_error() {+ let mut s = server();+ for (name, args) in [("execute", json!({"command": "madeup.thing"})), ("describe_command", json!({"id": "madeup.thing"}))] {+ let r = raw_tool(&mut s, name, args);+ assert_eq!(r["result"]["isError"], true, "{r}");+ let text = r["result"]["content"][0]["text"].as_str().unwrap();+ assert!(text.contains("unknown command `madeup.thing`"), "{text}");+ assert!(!text.contains("MCP tool"), "{text}");+ }+}++/// #10678: a valid engine command id that overlaps a tool name resolves as a command —+/// the engine accepts it before any tool-name hint could apply.+#[test]+fn valid_engine_command_id_overlapping_a_tool_name_resolves_as_command() {+ let mut b = Recorder { calls: Vec::new(), batch: Ok(json!({})) };+ let r = crate::tools::call_tool(&mut b, "execute", &json!({"command": "measure"}));+ assert_ne!(r["isError"], json!(true), "{r}");+ assert!(r["content"][0]["text"].as_str().unwrap().contains("measure"), "{r}");+ let r = crate::tools::call_tool(&mut b, "describe_command", &json!({"id": "measure"}));+ assert_ne!(r["isError"], json!(true), "{r}");+}+fn hostile_values() -> Vec<Value> {vec![Value::Null,diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rsindex 79333e05e2..4c8c57cba1 100644--- a/crates/mcp/src/tools.rs+++ b/crates/mcp/src/tools.rs@@ -729,6 +729,11 @@ fn command_error(command: &str, error: String) -> String {return error;}let id = command.split(['{', '(']).next().unwrap_or(command).trim();+ // An id that is exactly a registered tool name confuses the two namespaces: name the+ // distinction and its recovery instead of offering unrelated closest-command suggestions.+ if id == command.trim() && is_tool_name(id) {+ return tool_name_error(id);+ }let packed = id != command.trim();let normalize = |s: &str| s.chars().filter(char::is_ascii_alphanumeric).map(|c| c.to_ascii_lowercase()).collect::<String>();let normalized = normalize(id);@@ -762,6 +767,29 @@ fn command_error(command: &str, error: String) -> String {message}+/// Whether `name` is exactly a registered MCP tool name, read from the tool definitions+/// themselves so the two namespaces can never drift apart.+fn is_tool_name(name: &str) -> bool {+ tool_definitions().iter().any(|t| t["name"].as_str() == Some(name))+}++/// The reply when a rejected command id is exactly a tool name: the recovery belongs to the+/// tool namespace, not to a typo's closest-command suggestions.+fn tool_name_error(id: &str) -> String {+ format!(+ "unknown command `{id}`: `{id}` is an MCP tool, not an engine command id. Use MCP tools/list for its tool schema, or list_commands for engine command ids."+ )+}++/// A `describe_command` rejection of an id that is exactly a tool name gets the namespace+/// hint; every other error is left exactly as the engine said it.+fn describe_error(id: &str, error: String) -> String {+ if error.starts_with(&format!("unknown command `{id}`")) && is_tool_name(id) {+ return tool_name_error(id);+ }+ error+}+fn command_distance(a: &str, b: &str) -> usize {let mut row: Vec<usize> = (1..=b.len()).collect();for (i, ca) in a.bytes().enumerate() {@@ -808,7 +836,9 @@ fn dispatch(b: &mut dyn Backend, name: &str, a: &Map<String, Value>) -> Result<V}"describe_command" => {let id = str_arg(a, "id").ok_or("`id` is required")?;- exec(b, "engine.describe", json!({"command": id}))+ // The engine rejects the requested id inside its own error, so the tool-name+ // hint must inspect the `id`, not the outer `engine.describe` command `exec` sees.+ exec(b, "engine.describe", json!({"command": id})).map_err(|e| describe_error(id, e))}"execute" => {let id = str_arg(a, "command").ok_or("`command` is required")?;