refactor: clean up code by removing unused timeout variables and improving output handling in MCP tools tests

Author: jruokola

crates/codegraph-graph/src/file_watcher.rs

@@ -1,8 +1,6 @@
 use codegraph_core::{traits::FileWatcher, ChangeEvent, Result};
 use crossbeam_channel::Sender;
-use notify::{
-    recommended_watcher, Config, Event, PollWatcher, RecursiveMode, Watcher,
-};
+use notify::{recommended_watcher, Config, Event, PollWatcher, RecursiveMode, Watcher};
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::path::Path;
 use std::time::Duration;
@@ -34,7 +32,9 @@ impl FileWatcher for FileWatcherImpl {
             Ok(Ok(watcher)) => Box::new(watcher),
             Ok(Err(e)) => return Err(codegraph_core::CodeGraphError::Notify(e)),
             Err(_) => {
-                eprintln!("⚠️ macOS FSEvents watcher unavailable; falling back to polling file watcher");
+                eprintln!(
+                    "⚠️ macOS FSEvents watcher unavailable; falling back to polling file watcher"
+                );
                 let tx_clone = notify_tx.clone();
                 let poll_config = Config::default().with_poll_interval(Duration::from_secs(2));
                 let poll_watcher = PollWatcher::new(

crates/codegraph-mcp/src/connection.rs

@@ -12,7 +12,6 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::{broadcast, oneshot, RwLock};
-use tokio::time::timeout;
 use tracing::warn;
 use url::Url;
 
@@ -184,7 +183,7 @@ impl McpConnection {
         &self,
         method: &str,
         params: Value,
-        timeout_dur: Duration,
+        _timeout_dur: Duration,
     ) -> Result<JsonRpcMessage> {
         let id = uuid::Uuid::new_v4().to_string();
         let req = JsonRpcRequest::new(json!(id.clone()), method.to_string(), Some(params));
@@ -201,14 +200,13 @@ impl McpConnection {
             return Err(e);
         }
 
-        let res = timeout(timeout_dur, rx).await;
+        let res = rx.await;
         self.in_flight.fetch_sub(1, Ordering::SeqCst);
         match res {
-            Ok(Ok(msg)) => Ok(msg),
-            Ok(Err(_canceled)) => Err(McpError::ConnectionClosed),
-            Err(_elapsed) => {
+            Ok(msg) => Ok(msg),
+            Err(_canceled) => {
                 self.pending.remove(&id);
-                Err(McpError::RequestTimeout(method.to_string()))
+                Err(McpError::ConnectionClosed)
             }
         }
     }

crates/codegraph-mcp/src/official_server.rs

@@ -277,8 +277,12 @@ impl CodeGraphMCPServer {
                 "⚠️ CodeGraph open failed in writable mode ({}). Falling back to read-only mode.",
                 err
             );
-            codegraph_graph::CodeGraph::new_read_only()
-                .map_err(|ro_err| format!("Failed to initialize CodeGraph database: {} | {}", err, ro_err))
+            codegraph_graph::CodeGraph::new_read_only().map_err(|ro_err| {
+                format!(
+                    "Failed to initialize CodeGraph database: {} | {}",
+                    err, ro_err
+                )
+            })
         })?;
 
         Ok(Self {
@@ -1044,31 +1048,21 @@ impl CodeGraphMCPServer {
             let config = QwenConfig::default();
             let client = QwenClient::new(config.clone());
 
-            // Try to connect with a timeout to prevent hanging
-            let check_result = tokio::time::timeout(
-                std::time::Duration::from_secs(5),
-                client.check_availability(),
-            )
-            .await;
-
-            match check_result {
-                Ok(Ok(true)) => {
+            match client.check_availability().await {
+                Ok(true) => {
                     eprintln!("✅ Qwen2.5-Coder-14B-128K available for CodeGraph intelligence");
                     let mut qwen_lock = self.qwen_client.lock().await;
                     *qwen_lock = Some(client);
                 }
-                Ok(Ok(false)) => {
+                Ok(false) => {
                     eprintln!(
                         "⚠️ Qwen2.5-Coder model not found. Install with: ollama pull {}",
                         config.model_name
                     );
                 }
-                Ok(Err(e)) => {
+                Err(e) => {
                     eprintln!("❌ Failed to connect to Qwen2.5-Coder: {}", e);
                 }
-                Err(_) => {
-                    eprintln!("⚠️ Qwen2.5-Coder connection timed out after 5 seconds - Ollama may not be running");
-                }
             }
         }
         #[cfg(not(feature = "qwen-integration"))]

crates/codegraph-mcp/src/qwen.rs

@@ -2,7 +2,6 @@ use codegraph_core::{CodeGraphError, Result};
 use reqwest::Client;
 use serde::{Deserialize, Serialize};
 use std::time::{Duration, Instant};
-use tokio::time::timeout;
 use tracing::{debug, info, warn};
 
 /// Simple Qwen2.5-Coder client for MCP integration
@@ -127,21 +126,13 @@ impl QwenClient {
             self.config.context_window
         );
 
-        let response = timeout(
-            self.config.timeout,
-            self.client
-                .post(&format!("{}/api/chat", self.config.base_url))
-                .json(&request)
-                .send(),
-        )
-        .await
-        .map_err(|_| {
-            CodeGraphError::Timeout(format!(
-                "Qwen request timeout after {:?}",
-                self.config.timeout
-            ))
-        })?
-        .map_err(|e| CodeGraphError::Network(format!("Qwen request failed: {}", e)))?;
+        let response = self
+            .client
+            .post(&format!("{}/api/chat", self.config.base_url))
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| CodeGraphError::Network(format!("Qwen request failed: {}", e)))?;
 
         if !response.status().is_success() {
             let error_text = response
@@ -197,15 +188,14 @@ impl QwenClient {
             self.config.base_url
         );
 
-        let response = timeout(
-            Duration::from_secs(5),
-            self.client
-                .get(&format!("{}/api/tags", self.config.base_url))
-                .send(),
-        )
-        .await
-        .map_err(|_| CodeGraphError::Timeout("Qwen availability check timeout".to_string()))?
-        .map_err(|e| CodeGraphError::Network(format!("Qwen availability check failed: {}", e)))?;
+        let response = self
+            .client
+            .get(&format!("{}/api/tags", self.config.base_url))
+            .send()
+            .await
+            .map_err(|e| {
+                CodeGraphError::Network(format!("Qwen availability check failed: {}", e))
+            })?;
 
         if !response.status().is_success() {
             return Ok(false);

test_mcp_tools.py

@@ -58,16 +58,6 @@
     }),
 ]
 
-WAIT_OVERRIDE = {
-    101: 4.0,
-    102: 4.0,
-    103: 20.0,
-    104: 25.0,
-    105: 6.0,
-    106: 20.0,
-    107: 25.0,
-}
-
 def drain(proc, seconds=2.0):
     """Read stdout for up to `seconds`, print as it arrives, and return captured text."""
     out = []
@@ -92,7 +82,16 @@ def send(proc, obj, wait=2.0, show=True):
         print("="*72)
     proc.stdin.write(s + "\n")
     proc.stdin.flush()
-    return drain(proc, wait) if wait > 0 else ""
+    # Wait indefinitely (in 5-second chunks) until we receive output or the process exits.
+    output = ""
+    while True:
+        chunk = drain(proc, 5.0)
+        output += chunk
+        if chunk:
+            return output
+        # If the process exited and nothing new arrived, break to avoid hanging forever.
+        if proc.poll() is not None:
+            return output
 
 def extract_uuid(text: str):
     m = UUID_RE.search(text or "")
@@ -218,16 +217,7 @@ def run():
                 }
             }
 
-        wait_time = WAIT_OVERRIDE.get(payload["id"], 5.0)
-        out = send(proc, payload, wait=wait_time) + drain(proc, wait_time)
-
-        # If the tool still hasn't produced output (possible for long-running AI calls),
-        # keep waiting in generous chunks until we see something or the process exits.
-        while not out.strip():
-            extra = drain(proc, wait_time)
-            if not extra.strip():
-                break
-            out += extra
+        out = send(proc, payload, wait=0)
 
         if payload["id"] == 102:
             vec2_output = out