fix(binary-ninja-client): use GET + JSON for /decompile

The binja_mcp plugin's HTTP server only routes /decompile in do_GET
(http_server.py line 825). do_POST has no /decompile branch, so the
previous client code — which sent a form-urlencoded POST and then
treated the response body as the raw decompiled text — failed for
every function: the server fell through to a 4xx and the client
reported "Function not found" even though the function existed in
list_functions / search_functions.

Switch to GET ?name=<func> with reqwest's query() (consistent with
list_functions and search_functions in this same file), parse the
JSON {"decompiled": "..."} envelope, and surface the JSON "error"
field as either FunctionNotFound or RequestFailed. Keep a plain-text
fallback for older / future plugin variants that might return text.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Matt Davis

crates/binary-ninja-client/src/client.rs

@@ -223,28 +223,52 @@ impl BinaryNinjaClient {
         function_name: &str,
     ) -> Result<String> {
         let url = self.get_server_url(binary_id)?;
+        // binja_mcp serves /decompile via GET with ?name=<func>; the
+        // response is JSON of the form {"decompiled": "...", "function": {...}}
+        // matching the convention used by every other endpoint in the
+        // plugin. Earlier versions of this client sent POST with a form
+        // body, which the plugin's do_POST never routed — every call
+        // failed with what looked like "function not found".
         let decompile_url = format!("{}/decompile", url);
 
         debug!("Decompiling function: {}", function_name);
 
         let response = self
             .client
-            .post(&decompile_url)
-            .form(&[("name", function_name)])
+            .get(&decompile_url)
+            .query(&[("name", function_name)])
             .send()
             .await?;
 
         if !response.status().is_success() {
             return Err(BinaryNinjaError::FunctionNotFound(function_name.to_string()).into());
         }
 
-        let code = response.text().await?;
+        let text = response.text().await?;
+
+        // Preferred path: JSON response with "decompiled" field.
+        if let Ok(json_response) = serde_json::from_str::<serde_json::Value>(&text) {
+            if let Some(err) = json_response.get("error").and_then(|v| v.as_str()) {
+                if err.contains("not found") {
+                    return Err(BinaryNinjaError::FunctionNotFound(
+                        function_name.to_string(),
+                    )
+                    .into());
+                }
+                return Err(BinaryNinjaError::RequestFailed(err.to_string()).into());
+            }
+            if let Some(code) = json_response.get("decompiled").and_then(|v| v.as_str()) {
+                return Ok(code.to_string());
+            }
+        }
 
-        if code.starts_with("Error") || code.starts_with("Function not found") {
+        // Fallback: treat the body as raw decompiled text (older binja_mcp
+        // builds, or any future variant that returns plain text).
+        if text.starts_with("Error") || text.starts_with("Function not found") {
             return Err(BinaryNinjaError::FunctionNotFound(function_name.to_string()).into());
         }
 
-        Ok(code)
+        Ok(text)
     }
 
     /// Get detailed information about a function including decompiled code