Stop sending a null threshold, and show what the engine actually said

Live testing: mem0 store and list succeeded, recall answered 400. The
cause is that `RecallOpts::min_score` is an `Option<f64>` and the search
body interpolated it directly, so an unset minimum serialised as
`"threshold": null`. The hosted platform types that field as a number in
0..=1 and rejects an explicit null. `search_body` now omits the field
when no minimum was asked for, and clamps `top_k` into the documented
1..=1000 for the same reason -- a limit outside the range is a
validation error, not a smaller result set.

The 400 was harder to diagnose than it should have been, because the
error carried a status and nothing else. Hosted engines explain
themselves in the response body -- mem0 answers `{"detail": "..."}`,
cognee likewise -- and `status_error` was discarding it, turning "this
one field is invalid" into "something, somewhere, was wrong". It now
includes the body, truncated to 300 characters: an error body is not a
payload budget, and only error bodies reach this path.

Both flavours share the builder, so the self-hosted arm stops sending a
null threshold too -- its server tolerated it, which is why this went
unnoticed there.

cargo test -p tinymemory-remote --lib: 27 passed (3 new, pinning the
  omitted threshold, the sent one, and the clamp)

Author: YellowSnnowmann

adapters/remote/src/common.rs

@@ -196,8 +196,24 @@ impl HttpClient {
     /// rejected credential specifically, because "HTTP 401" three layers deep
     /// in an anyhow chain reads as "the engine is down" and sends the operator
     /// to the wrong runbook.
-    fn status_error(&self, path: &str, status: reqwest::StatusCode) -> anyhow::Error {
+    fn status_error(&self, path: &str, status: reqwest::StatusCode, body: &str) -> anyhow::Error {
         let host = self.endpoint.host_str().unwrap_or("<endpoint>");
+        // Hosted engines explain a rejection in the response body — mem0
+        // answers `{"detail": "..."}`, cognee likewise — and discarding it
+        // turned "this one field is invalid" into a bare status code that
+        // said only that something, somewhere, was wrong. Truncated because
+        // an error body is not a payload budget, and only ever an error
+        // body: success responses never reach here.
+        let detail = body.trim();
+        let detail = if detail.is_empty() {
+            String::new()
+        } else {
+            let mut shown: String = detail.chars().take(300).collect();
+            if detail.chars().count() > 300 {
+                shown.push('…');
+            }
+            format!(" — {shown}")
+        };
         match status.as_u16() {
             401 | 403 => {
                 let hint = match &self.auth {
@@ -209,10 +225,10 @@ impl HttpClient {
                 };
                 anyhow::anyhow!(
                     "memory API {path} on {host}: the configured credential was rejected \
-                     (HTTP {status}) — {hint}"
+                     (HTTP {status}) — {hint}{detail}"
                 )
             }
-            _ => anyhow::anyhow!("memory API {path} on {host} returned HTTP {status}"),
+            _ => anyhow::anyhow!("memory API {path} on {host} returned HTTP {status}{detail}"),
         }
     }
 
@@ -232,7 +248,8 @@ impl HttpClient {
             .map_err(|error| self.transport_error(error))?;
         let status = response.status();
         if !status.is_success() {
-            return Err(self.status_error(path, status));
+            let body = response.text().await.unwrap_or_default();
+            return Err(self.status_error(path, status, &body));
         }
         let body = read_capped(response, path).await?;
         serde_json::from_slice(&body)
@@ -248,7 +265,8 @@ impl HttpClient {
             .map_err(|error| self.transport_error(error))?;
         let status = response.status();
         if !status.is_success() {
-            return Err(self.status_error(path, status));
+            let body = response.text().await.unwrap_or_default();
+            return Err(self.status_error(path, status, &body));
         }
         let body = read_capped(response, path).await?;
         String::from_utf8(body).context("memory API response was not valid UTF-8")
@@ -271,7 +289,8 @@ impl HttpClient {
             .map_err(|error| self.transport_error(error))?;
         let status = response.status();
         if !status.is_success() {
-            return Err(self.status_error(path, status));
+            let body = response.text().await.unwrap_or_default();
+            return Err(self.status_error(path, status, &body));
         }
         Ok(status)
     }

adapters/remote/src/mem0.rs

@@ -286,6 +286,26 @@ impl Mem0Dialect {
         }
     }
 
+    /// The search body both flavours send.
+    ///
+    /// `threshold` is **omitted** rather than sent as null when the caller set
+    /// no minimum score: the platform types it as a number in 0..=1 and
+    /// rejects an explicit null with a 400, which is how a recall against
+    /// mem0's hosted API failed while store and list succeeded. `top_k` is
+    /// clamped to the documented 1..=1000 for the same reason — a limit
+    /// outside it is a validation error, not a smaller result set.
+    fn search_body(query: &str, limit: usize, filters: Value, min_score: Option<f64>) -> Value {
+        let mut body = json!({
+            "query": query,
+            "filters": filters,
+            "top_k": limit.clamp(1, 1000),
+        });
+        if let (Some(object), Some(threshold)) = (body.as_object_mut(), min_score) {
+            object.insert("threshold".into(), json!(threshold));
+        }
+        body
+    }
+
     /// The path addressing one record by its remote id.
     ///
     /// The platform serves the by-id operations under **v1** while add,
@@ -421,9 +441,12 @@ impl Dialect for Mem0Dialect {
                     .json(
                         Method::POST,
                         "search",
-                        Some(&json!({
-                            "query": query, "filters": filters, "top_k": limit, "threshold": opts.min_score
-                        })),
+                        Some(&Self::search_body(
+                            query,
+                            limit,
+                            Value::Object(filters),
+                            opts.min_score,
+                        )),
                     )
                     .await?
             }
@@ -442,9 +465,7 @@ impl Dialect for Mem0Dialect {
                     .json(
                         Method::POST,
                         "v3/memories/search/",
-                        Some(&json!({
-                            "query": query, "filters": filters, "top_k": limit, "threshold": opts.min_score
-                        })),
+                        Some(&Self::search_body(query, limit, filters, opts.min_score)),
                     )
                     .await?
             }
@@ -483,3 +504,42 @@ impl Dialect for Mem0Dialect {
 #[cfg(test)]
 #[path = "mem0_test.rs"]
 mod test;
+
+#[cfg(test)]
+mod search_body_tests {
+    use super::*;
+
+    /// A recall with no minimum score must omit `threshold`, not send null.
+    /// The hosted platform types it as a number in 0..=1 and answers 400 to
+    /// an explicit null — store and list succeeded while recall failed.
+    #[test]
+    fn an_unset_min_score_omits_the_threshold_field() {
+        let body = Mem0Dialect::search_body("q", 10, json!({"user_id": "ns"}), None);
+        assert!(
+            body.get("threshold").is_none(),
+            "threshold must be absent, not null: {body}"
+        );
+        assert_eq!(body["top_k"], 10);
+        assert_eq!(body["query"], "q");
+    }
+
+    #[test]
+    fn a_set_min_score_is_sent() {
+        let body = Mem0Dialect::search_body("q", 10, json!({"user_id": "ns"}), Some(0.25));
+        assert_eq!(body["threshold"], 0.25);
+    }
+
+    /// `top_k` outside the documented 1..=1000 is a validation error, so a
+    /// caller's limit is clamped rather than forwarded into a 400.
+    #[test]
+    fn top_k_is_clamped_to_the_documented_range() {
+        assert_eq!(
+            Mem0Dialect::search_body("q", 0, json!({}), None)["top_k"],
+            1
+        );
+        assert_eq!(
+            Mem0Dialect::search_body("q", 5000, json!({}), None)["top_k"],
+            1000
+        );
+    }
+}