fix(core): allow server to start with no LSP servers configured

When lsp_servers is empty the server starts in protocol-only mode
instead of returning NoServersAvailable. MCP tools that require LSP
will still fail at call time, but protocol handshake (initialize,
list_tools) works without any LSP server present.

Update two tests that expected the old NoServersAvailable behavior.

Author: bug-ops

crates/mcpls-core/src/bridge/translator.rs

@@ -2778,13 +2778,14 @@ mod tests {
         assert_eq!(extension_map.get("nu"), Some(&"nushell".to_string()));
         assert_eq!(extension_map.get("rs"), Some(&"rust".to_string()));
 
+        // serve() starts in protocol-only mode when no LSP servers are configured;
+        // it may return a transport error but must not return NoServersAvailable.
         let result = crate::serve(config).await;
-        assert!(result.is_err());
-
-        if let Err(crate::error::Error::NoServersAvailable(msg)) = result {
-            assert!(msg.contains("none configured"));
-        } else {
-            panic!("Expected NoServersAvailable error for empty server config");
+        if let Err(ref err) = result {
+            assert!(
+                !matches!(err, crate::error::Error::NoServersAvailable(_)),
+                "serve() must not return NoServersAvailable for empty lsp_servers config"
+            );
         }
     }
 }

crates/mcpls-core/src/lib.rs

@@ -147,45 +147,42 @@ pub async fn serve(config: ServerConfig) -> Result<(), Error> {
         applicable_configs.len()
     );
 
-    // Spawn all servers with graceful degradation
-    let result = LspServer::spawn_batch(&applicable_configs).await;
-
-    // Handle the three possible outcomes
-    if result.all_failed() {
-        return Err(Error::AllServersFailedToInit {
-            count: result.failure_count(),
-            failures: result.failures,
-        });
-    }
+    if !applicable_configs.is_empty() {
+        // Spawn all servers with graceful degradation
+        let result = LspServer::spawn_batch(&applicable_configs).await;
+
+        // Handle the three possible outcomes
+        if result.all_failed() {
+            return Err(Error::AllServersFailedToInit {
+                count: result.failure_count(),
+                failures: result.failures,
+            });
+        }
 
-    if result.partial_success() {
-        warn!(
-            "Partial server initialization: {} succeeded, {} failed",
-            result.server_count(),
-            result.failure_count()
-        );
-        for failure in &result.failures {
-            error!("Server initialization failed: {}", failure);
+        if result.partial_success() {
+            warn!(
+                "Partial server initialization: {} succeeded, {} failed",
+                result.server_count(),
+                result.failure_count()
+            );
+            for failure in &result.failures {
+                error!("Server initialization failed: {}", failure);
+            }
         }
-    }
 
-    // Check if at least one server successfully initialized
-    if !result.has_servers() {
-        return Err(Error::NoServersAvailable(
-            "none configured or all failed to initialize".to_string(),
-        ));
-    }
+        // Register all successfully initialized servers
+        let server_count = result.server_count();
+        for (language_id, server) in result.servers {
+            let client = server.client().clone();
+            translator.register_client(language_id.clone(), client);
+            translator.register_server(language_id.clone(), server);
+        }
 
-    // Register all successfully initialized servers
-    let server_count = result.server_count();
-    for (language_id, server) in result.servers {
-        let client = server.client().clone();
-        translator.register_client(language_id.clone(), client);
-        translator.register_server(language_id.clone(), server);
+        info!("Proceeding with {} LSP server(s)", server_count);
+    } else {
+        warn!("No applicable LSP servers configured — starting in protocol-only mode");
     }
 
-    info!("Proceeding with {} LSP server(s)", server_count);
-
     let translator = Arc::new(Mutex::new(translator));
 
     info!("Starting MCP server with rmcp...");
@@ -502,10 +499,12 @@ mod tests {
         }
 
         #[tokio::test]
-        async fn test_serve_fails_with_empty_config() {
+        async fn test_serve_starts_with_empty_config() {
             use crate::config::WorkspaceConfig;
 
-            // Create a config with no servers
+            // Server starts in protocol-only mode when no LSP servers are configured.
+            // serve() blocks until the MCP transport closes, so it will error with a
+            // connection/transport error — not NoServersAvailable.
             let config = ServerConfig {
                 workspace: WorkspaceConfig {
                     roots: vec![PathBuf::from("/tmp/test-workspace")],
@@ -518,17 +517,13 @@ mod tests {
 
             let result = serve(config).await;
 
-            assert!(result.is_err());
-            let err = result.unwrap_err();
-
-            // Should return NoServersAvailable because no servers were configured
-            assert!(
-                matches!(err, Error::NoServersAvailable(_)),
-                "Expected NoServersAvailable error, got: {err:?}"
-            );
-
-            if let Error::NoServersAvailable(msg) = err {
-                assert!(msg.contains("none configured"));
+            // serve() may succeed or fail with a transport error, but must NOT
+            // return NoServersAvailable when the config simply has no servers.
+            if let Err(ref err) = result {
+                assert!(
+                    !matches!(err, Error::NoServersAvailable(_)),
+                    "serve() must not return NoServersAvailable for empty lsp_servers config"
+                );
             }
         }
     }