feat: implement retry mechanism for MCP server activation with exponential backoff

Author: samhvw8

src-tauri/src/core/mcp.rs

@@ -4,7 +4,7 @@ use serde_json::{Map, Value};
 use std::fs;
 use std::{collections::HashMap, env, sync::Arc, time::Duration};
 use tauri::{AppHandle, Emitter, Runtime, State};
-use tokio::{process::Command, sync::Mutex, time::timeout};
+use tokio::{process::Command, sync::Mutex, time::{timeout, sleep}};
 
 use super::{cmd::get_jan_data_folder_path, state::AppState};
 
@@ -13,6 +13,12 @@ const DEFAULT_MCP_CONFIG: &str = r#"{"mcpServers":{"browsermcp":{"command":"npx"
 // Timeout for MCP tool calls (30 seconds)
 const MCP_TOOL_CALL_TIMEOUT: Duration = Duration::from_secs(30);
 
+// Maximum retry attempts for MCP server loading
+const MAX_MCP_RETRY_ATTEMPTS: u32 = 3;
+
+// Base backoff duration in milliseconds (exponential backoff will multiply this)
+const BASE_BACKOFF_MS: u64 = 1000;
+
 /// Runs MCP commands by reading configuration from a JSON file and initializing servers
 ///
 /// # Arguments
@@ -46,30 +52,103 @@ pub async fn run_mcp_commands<R: Runtime>(
                 log::trace!("Server {name} is not active, skipping.");
                 continue;
             }
-            match start_mcp_server(
+            
+            // Try to start the server with retry mechanism
+            start_mcp_server(
                 app.clone(),
                 servers_state.clone(),
                 name.clone(),
                 config.clone(),
             )
-            .await
-            {
-                Ok(_) => {
-                    log::info!("Server {name} activated successfully.");
-                }
-                Err(e) => {
+            .await;
+        }
+    }
+
+    Ok(())
+}
+
+/// Starts an MCP server with retry mechanism using exponential backoff
+async fn start_mcp_server<R: Runtime>(
+    app: AppHandle<R>,
+    servers_state: Arc<Mutex<HashMap<String, RunningService<RoleClient, ()>>>>,
+    name: String,
+    config: Value,
+) {
+    // Initialize retry state locally for this server start attempt
+    let mut retry_count = 0;
+    let mut backoff_ms = BASE_BACKOFF_MS;
+    
+    loop {
+        retry_count += 1;
+        
+        if retry_count > 1 {
+            log::info!(
+                "Starting MCP server {name} - retry attempt {} of {} (waiting {:.1}s)",
+                retry_count,
+                MAX_MCP_RETRY_ATTEMPTS,
+                backoff_ms as f64 / 1000.0
+            );
+            
+            let _ = app.emit(
+                "mcp-retry-attempt",
+                serde_json::json!({
+                    "server": name,
+                    "attempt": retry_count,
+                    "max_attempts": MAX_MCP_RETRY_ATTEMPTS
+                })
+            );
+            
+            sleep(Duration::from_millis(backoff_ms)).await;
+        } else {
+            log::info!("Starting MCP server {name} - initial attempt");
+        }
+        
+        // Attempt to start the server
+        match start_mcp_server_internal(app.clone(), servers_state.clone(), name.clone(), config.clone()).await {
+            Ok(_) => {
+                log::info!("Server {name} activated successfully.");
+                
+                let _ = app.emit(
+                    "mcp-server-started",
+                    serde_json::json!({
+                        "server": name,
+                        "status": "success",
+                        "attempts": retry_count
+                    })
+                );
+                return;
+            }
+            Err(e) => {
+                log::error!("Failed to activate server {name} (attempt {retry_count}): {e}");
+                
+                if retry_count >= MAX_MCP_RETRY_ATTEMPTS {
+                    log::error!(
+                        "Server {name} has exceeded maximum retry attempts ({}). Giving up.",
+                        MAX_MCP_RETRY_ATTEMPTS
+                    );
                     let _ = app.emit(
-                        "mcp-error",
-                        format!("Failed to activate MCP server {name}: {e}"),
+                        "mcp-max-retries-exceeded",
+                        format!("MCP server {name} failed after {MAX_MCP_RETRY_ATTEMPTS} attempts: {e}"),
                     );
-                    log::error!("Failed to activate server {name}: {e}");
-                    continue; // Skip to the next server
+                    return;
+                } else {
+                    let _ = app.emit(
+                        "mcp-retry-scheduled",
+                        serde_json::json!({
+                            "server": name,
+                            "attempt": retry_count,
+                            "max_attempts": MAX_MCP_RETRY_ATTEMPTS,
+                            "error": e,
+                            "next_retry_in_ms": backoff_ms
+                        })
+                    );
+                    
+                    // Update backoff duration for next attempt (exponential backoff)
+                    backoff_ms = (backoff_ms * 2).min(30000); // Cap at 30 seconds
                 }
             }
         }
     }
-
-    Ok(())
 }
 
 #[tauri::command]
@@ -81,10 +160,11 @@ pub async fn activate_mcp_server<R: Runtime>(
 ) -> Result<(), String> {
     let servers: Arc<Mutex<HashMap<String, RunningService<RoleClient, ()>>>> =
         state.mcp_servers.clone();
-    start_mcp_server(app, servers, name, config).await
+    start_mcp_server(app, servers, name, config).await;
+    Ok(())
 }
 
-async fn start_mcp_server<R: Runtime>(
+async fn start_mcp_server_internal<R: Runtime>(
     app: tauri::AppHandle<R>,
     servers: Arc<Mutex<HashMap<String, RunningService<RoleClient, ()>>>>,
     name: String,