fix: Resolve merge conflict in server/mod.rsmakima/discuss-contract-feature

Combine imports from both branches - include both chains and contract_discuss handlers.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

1 files changed, 42 insertions, 0 deletions

diff --git a/makima/src/daemon/api/client.rs b/makima/src/daemon/api/client.rs
index 4ba4778..dbf3101 100644
--- a/makima/src/daemon/api/client.rs
+++ b/makima/src/daemon/api/client.rs
@@ -276,6 +276,48 @@ impl ApiClient {
         Err(last_error.unwrap())
     }
 
+    /// Make a DELETE request with response and retry.
+    pub async fn delete_with_response<T: DeserializeOwned>(&self, path: &str) -> Result<T, ApiError> {
+        let url = format!("{}{}", self.base_url, path);
+        let mut last_error = None;
+
+        for attempt in 0..MAX_RETRIES {
+            if attempt > 0 {
+                tokio::time::sleep(Self::backoff_delay(attempt - 1)).await;
+            }
+
+            let result = self.client
+                .delete(&url)
+                .header("X-Makima-Tool-Key", &self.api_key)
+                .header("X-Makima-API-Key", &self.api_key)
+                .send()
+                .await;
+
+            match result {
+                Ok(response) => {
+                    match self.handle_response(response).await {
+                        Ok(value) => return Ok(value),
+                        Err(e) if Self::is_retryable(&e) && attempt < MAX_RETRIES - 1 => {
+                            last_error = Some(e);
+                            continue;
+                        }
+                        Err(e) => return Err(e),
+                    }
+                }
+                Err(e) => {
+                    let error = ApiError::Request(e);
+                    if Self::is_retryable(&error) && attempt < MAX_RETRIES - 1 {
+                        last_error = Some(error);
+                        continue;
+                    }
+                    return Err(error);
+                }
+            }
+        }
+
+        Err(last_error.unwrap())
+    }
+
     /// Handle API response.
     async fn handle_response<T: DeserializeOwned>(
         &self,