[router] Add rustfmt and set group imports by default (#11732)

sgl-router/tests/api_endpoints_test.rs

@@ -1,5 +1,7 @@
 mod common;
 
+use std::sync::Arc;
+
 use axum::{
     body::Body,
     extract::Request,
@@ -8,13 +10,14 @@ use axum::{
 use common::mock_worker::{HealthStatus, MockWorker, MockWorkerConfig, WorkerType};
 use reqwest::Client;
 use serde_json::json;
-use sglang_router_rs::config::{
-    CircuitBreakerConfig, ConnectionMode, PolicyConfig, RetryConfig, RouterConfig, RoutingMode,
+use sglang_router_rs::{
+    config::{
+        CircuitBreakerConfig, ConnectionMode, PolicyConfig, RetryConfig, RouterConfig, RoutingMode,
+    },
+    core::WorkerManager,
+    routers::{RouterFactory, RouterTrait},
+    server::AppContext,
 };
-use sglang_router_rs::core::WorkerManager;
-use sglang_router_rs::routers::{RouterFactory, RouterTrait};
-use sglang_router_rs::server::AppContext;
-use std::sync::Arc;
 use tower::ServiceExt;
 
 /// Test context that manages mock workers
@@ -995,9 +998,10 @@ mod router_policy_tests {
 
 #[cfg(test)]
 mod responses_endpoint_tests {
-    use super::*;
     use reqwest::Client as HttpClient;
 
+    use super::*;
+
     #[tokio::test]
     async fn test_v1_responses_non_streaming() {
         let ctx = TestContext::new(vec![MockWorkerConfig {

sgl-router/tests/cache_aware_backward_compat_test.rs

@@ -1,7 +1,9 @@
-use sglang_router_rs::core::{BasicWorkerBuilder, Worker, WorkerType};
-use sglang_router_rs::policies::{CacheAwareConfig, CacheAwarePolicy, LoadBalancingPolicy};
-use std::collections::HashMap;
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
+
+use sglang_router_rs::{
+    core::{BasicWorkerBuilder, Worker, WorkerType},
+    policies::{CacheAwareConfig, CacheAwarePolicy, LoadBalancingPolicy},
+};
 
 #[test]
 fn test_backward_compatibility_with_empty_model_id() {

sgl-router/tests/chat_template_format_detection.rs

@@ -1,7 +1,9 @@
-use sglang_router_rs::protocols::chat::{ChatMessage, UserMessageContent};
-use sglang_router_rs::tokenizer::chat_template::{
-    detect_chat_template_content_format, ChatTemplateContentFormat, ChatTemplateParams,
-    ChatTemplateProcessor,
+use sglang_router_rs::{
+    protocols::chat::{ChatMessage, UserMessageContent},
+    tokenizer::chat_template::{
+        detect_chat_template_content_format, ChatTemplateContentFormat, ChatTemplateParams,
+        ChatTemplateProcessor,
+    },
 };
 
 #[test]

sgl-router/tests/chat_template_integration.rs

@@ -1,8 +1,12 @@
-use sglang_router_rs::protocols::chat::{ChatMessage, UserMessageContent};
-use sglang_router_rs::protocols::common::{ContentPart, ImageUrl};
-use sglang_router_rs::tokenizer::chat_template::{
-    detect_chat_template_content_format, ChatTemplateContentFormat, ChatTemplateParams,
-    ChatTemplateProcessor,
+use sglang_router_rs::{
+    protocols::{
+        chat::{ChatMessage, UserMessageContent},
+        common::{ContentPart, ImageUrl},
+    },
+    tokenizer::chat_template::{
+        detect_chat_template_content_format, ChatTemplateContentFormat, ChatTemplateParams,
+        ChatTemplateProcessor,
+    },
 };
 
 #[test]

sgl-router/tests/chat_template_loading.rs

@@ -1,9 +1,11 @@
 #[cfg(test)]
 mod tests {
-    use sglang_router_rs::protocols::chat::{ChatMessage, UserMessageContent};
-    use sglang_router_rs::tokenizer::chat_template::ChatTemplateParams;
-    use sglang_router_rs::tokenizer::huggingface::HuggingFaceTokenizer;
     use std::fs;
+
+    use sglang_router_rs::{
+        protocols::chat::{ChatMessage, UserMessageContent},
+        tokenizer::{chat_template::ChatTemplateParams, huggingface::HuggingFaceTokenizer},
+    };
     use tempfile::TempDir;
 
     #[test]

sgl-router/tests/common/mock_mcp_server.rs

@@ -148,8 +148,7 @@ mod tests {
     async fn test_mock_server_with_rmcp_client() {
         let mut server = MockMCPServer::start().await.unwrap();
 
-        use rmcp::transport::StreamableHttpClientTransport;
-        use rmcp::ServiceExt;
+        use rmcp::{transport::StreamableHttpClientTransport, ServiceExt};
 
         let transport = StreamableHttpClientTransport::from_uri(server.url().as_str());
         let client = ().serve(transport).await;

sgl-router/tests/common/mock_openai_server.rs

@@ -2,19 +2,21 @@
 
 #![allow(dead_code)]
 
+use std::{net::SocketAddr, sync::Arc};
+
 use axum::{
     body::Body,
     extract::{Request, State},
     http::{HeaderValue, StatusCode},
-    response::sse::{Event, KeepAlive},
-    response::{IntoResponse, Response, Sse},
+    response::{
+        sse::{Event, KeepAlive},
+        IntoResponse, Response, Sse,
+    },
     routing::post,
     Json, Router,
 };
 use futures_util::stream::{self, StreamExt};
 use serde_json::json;
-use std::net::SocketAddr;
-use std::sync::Arc;
 use tokio::net::TcpListener;
 
 /// Mock OpenAI API server for testing

sgl-router/tests/common/mock_worker.rs

@@ -1,20 +1,25 @@
 // Mock worker for testing - these functions are used by integration tests
 #![allow(dead_code)]
 
+use std::{
+    collections::{HashMap, HashSet},
+    convert::Infallible,
+    sync::{Arc, Mutex, OnceLock},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
 use axum::{
     extract::{Json, Path, State},
     http::StatusCode,
-    response::sse::{Event, KeepAlive},
-    response::{IntoResponse, Response, Sse},
+    response::{
+        sse::{Event, KeepAlive},
+        IntoResponse, Response, Sse,
+    },
     routing::{get, post},
     Router,
 };
 use futures_util::stream::{self, StreamExt};
 use serde_json::json;
-use std::collections::{HashMap, HashSet};
-use std::convert::Infallible;
-use std::sync::{Arc, Mutex, OnceLock};
-use std::time::{SystemTime, UNIX_EPOCH};
 use tokio::sync::RwLock;
 use uuid::Uuid;
 

sgl-router/tests/common/mod.rs

@@ -7,19 +7,24 @@ pub mod mock_worker;
 pub mod streaming_helpers;
 pub mod test_app;
 
-use serde_json::json;
-use sglang_router_rs::config::RouterConfig;
-use sglang_router_rs::core::{LoadMonitor, WorkerRegistry};
-use sglang_router_rs::data_connector::{
-    MemoryConversationItemStorage, MemoryConversationStorage, MemoryResponseStorage,
+use std::{
+    fs,
+    path::PathBuf,
+    sync::{Arc, Mutex, OnceLock},
+};
+
+use serde_json::json;
+use sglang_router_rs::{
+    config::RouterConfig,
+    core::{LoadMonitor, WorkerRegistry},
+    data_connector::{
+        MemoryConversationItemStorage, MemoryConversationStorage, MemoryResponseStorage,
+    },
+    middleware::TokenBucket,
+    policies::PolicyRegistry,
+    protocols::common::{Function, Tool},
+    server::AppContext,
 };
-use sglang_router_rs::middleware::TokenBucket;
-use sglang_router_rs::policies::PolicyRegistry;
-use sglang_router_rs::protocols::common::{Function, Tool};
-use sglang_router_rs::server::AppContext;
-use std::fs;
-use std::path::PathBuf;
-use std::sync::{Arc, Mutex, OnceLock};
 
 /// Helper function to create AppContext for tests
 pub fn create_test_context(config: RouterConfig) -> Arc<AppContext> {

sgl-router/tests/common/test_app.rs

@@ -1,3 +1,5 @@
+use std::sync::{Arc, OnceLock};
+
 use axum::Router;
 use reqwest::Client;
 use sglang_router_rs::{
@@ -11,7 +13,6 @@ use sglang_router_rs::{
     routers::RouterTrait,
     server::{build_app, AppContext, AppState},
 };
-use std::sync::{Arc, OnceLock};
 
 /// Create a test Axum application using the actual server's build_app function
 #[allow(dead_code)]

sgl-router/tests/mcp_test.rs

@@ -9,10 +9,11 @@
 
 mod common;
 
+use std::collections::HashMap;
+
 use common::mock_mcp_server::MockMCPServer;
 use serde_json::json;
 use sglang_router_rs::mcp::{McpClientManager, McpConfig, McpError, McpServerConfig, McpTransport};
-use std::collections::HashMap;
 
 /// Create a new mock server for testing (each test gets its own)
 async fn create_mock_server() -> MockMCPServer {

sgl-router/tests/policy_registry_integration.rs

@@ -1,12 +1,11 @@
 //! Integration tests for PolicyRegistry with RouterManager
 
-use sglang_router_rs::config::PolicyConfig;
-use sglang_router_rs::core::WorkerRegistry;
-use sglang_router_rs::policies::PolicyRegistry;
-use sglang_router_rs::protocols::worker_spec::WorkerConfigRequest;
-use sglang_router_rs::routers::router_manager::RouterManager;
-use std::collections::HashMap;
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
+
+use sglang_router_rs::{
+    config::PolicyConfig, core::WorkerRegistry, policies::PolicyRegistry,
+    protocols::worker_spec::WorkerConfigRequest, routers::router_manager::RouterManager,
+};
 
 #[tokio::test]
 async fn test_policy_registry_with_router_manager() {
@@ -95,8 +94,7 @@ async fn test_policy_registry_with_router_manager() {
 
 #[test]
 fn test_policy_registry_cleanup() {
-    use sglang_router_rs::config::PolicyConfig;
-    use sglang_router_rs::policies::PolicyRegistry;
+    use sglang_router_rs::{config::PolicyConfig, policies::PolicyRegistry};
 
     let registry = PolicyRegistry::new(PolicyConfig::RoundRobin);
 
@@ -123,8 +121,7 @@ fn test_policy_registry_cleanup() {
 
 #[test]
 fn test_policy_registry_multiple_models() {
-    use sglang_router_rs::config::PolicyConfig;
-    use sglang_router_rs::policies::PolicyRegistry;
+    use sglang_router_rs::{config::PolicyConfig, policies::PolicyRegistry};
 
     let registry = PolicyRegistry::new(PolicyConfig::RoundRobin);
 

sgl-router/tests/request_formats_test.rs

@@ -1,12 +1,15 @@
 mod common;
 
+use std::sync::Arc;
+
 use common::mock_worker::{HealthStatus, MockWorker, MockWorkerConfig, WorkerType};
 use reqwest::Client;
 use serde_json::json;
-use sglang_router_rs::config::{RouterConfig, RoutingMode};
-use sglang_router_rs::core::WorkerManager;
-use sglang_router_rs::routers::{RouterFactory, RouterTrait};
-use std::sync::Arc;
+use sglang_router_rs::{
+    config::{RouterConfig, RoutingMode},
+    core::WorkerManager,
+    routers::{RouterFactory, RouterTrait},
+};
 
 /// Test context that manages mock workers
 struct TestContext {

sgl-router/tests/responses_api_test.rs

@@ -1,22 +1,26 @@
 // Integration test for Responses API
 
 use axum::http::StatusCode;
-use sglang_router_rs::protocols::common::{
-    GenerationRequest, ToolChoice, ToolChoiceValue, UsageInfo,
-};
-use sglang_router_rs::protocols::responses::{
-    ReasoningEffort, ResponseInput, ResponseReasoningParam, ResponseTool, ResponseToolType,
-    ResponsesRequest, ServiceTier, Truncation,
+use sglang_router_rs::protocols::{
+    common::{GenerationRequest, ToolChoice, ToolChoiceValue, UsageInfo},
+    responses::{
+        ReasoningEffort, ResponseInput, ResponseReasoningParam, ResponseTool, ResponseToolType,
+        ResponsesRequest, ServiceTier, Truncation,
+    },
 };
 
 mod common;
-use common::mock_mcp_server::MockMCPServer;
-use common::mock_worker::{HealthStatus, MockWorker, MockWorkerConfig, WorkerType};
-use sglang_router_rs::config::{
-    CircuitBreakerConfig, ConnectionMode, HealthCheckConfig, PolicyConfig, RetryConfig,
-    RouterConfig, RoutingMode,
+use common::{
+    mock_mcp_server::MockMCPServer,
+    mock_worker::{HealthStatus, MockWorker, MockWorkerConfig, WorkerType},
+};
+use sglang_router_rs::{
+    config::{
+        CircuitBreakerConfig, ConnectionMode, HealthCheckConfig, PolicyConfig, RetryConfig,
+        RouterConfig, RoutingMode,
+    },
+    routers::RouterFactory,
 };
-use sglang_router_rs::routers::RouterFactory;
 
 #[tokio::test]
 async fn test_non_streaming_mcp_minimal_e2e_with_persistence() {

sgl-router/tests/spec/chat_completion.rs

@@ -1,10 +1,12 @@
 use serde_json::json;
-use sglang_router_rs::protocols::chat::{ChatCompletionRequest, ChatMessage, UserMessageContent};
-use sglang_router_rs::protocols::common::{
-    Function, FunctionCall, FunctionChoice, StreamOptions, Tool, ToolChoice, ToolChoiceValue,
-    ToolReference,
+use sglang_router_rs::protocols::{
+    chat::{ChatCompletionRequest, ChatMessage, UserMessageContent},
+    common::{
+        Function, FunctionCall, FunctionChoice, StreamOptions, Tool, ToolChoice, ToolChoiceValue,
+        ToolReference,
+    },
+    validated::Normalizable,
 };
-use sglang_router_rs::protocols::validated::Normalizable;
 use validator::Validate;
 
 // Deprecated fields normalization tests

sgl-router/tests/spec/embedding.rs

@@ -1,6 +1,5 @@
 use serde_json::{from_str, json, to_string};
-use sglang_router_rs::protocols::common::GenerationRequest;
-use sglang_router_rs::protocols::embedding::EmbeddingRequest;
+use sglang_router_rs::protocols::{common::GenerationRequest, embedding::EmbeddingRequest};
 
 #[test]
 fn test_embedding_request_serialization_string_input() {

sgl-router/tests/spec/rerank.rs

@@ -1,9 +1,10 @@
-use serde_json::{from_str, to_string, Number, Value};
-use sglang_router_rs::protocols::common::{GenerationRequest, StringOrArray, UsageInfo};
-use sglang_router_rs::protocols::rerank::{
-    RerankRequest, RerankResponse, RerankResult, V1RerankReqInput,
-};
 use std::collections::HashMap;
+
+use serde_json::{from_str, to_string, Number, Value};
+use sglang_router_rs::protocols::{
+    common::{GenerationRequest, StringOrArray, UsageInfo},
+    rerank::{RerankRequest, RerankResponse, RerankResult, V1RerankReqInput},
+};
 use validator::Validate;
 
 #[test]

sgl-router/tests/streaming_tests.rs

@@ -1,13 +1,16 @@
 mod common;
 
+use std::sync::Arc;
+
 use common::mock_worker::{HealthStatus, MockWorker, MockWorkerConfig, WorkerType};
 use futures_util::StreamExt;
 use reqwest::Client;
 use serde_json::json;
-use sglang_router_rs::config::{RouterConfig, RoutingMode};
-use sglang_router_rs::core::WorkerManager;
-use sglang_router_rs::routers::{RouterFactory, RouterTrait};
-use std::sync::Arc;
+use sglang_router_rs::{
+    config::{RouterConfig, RoutingMode},
+    core::WorkerManager,
+    routers::{RouterFactory, RouterTrait},
+};
 
 /// Test context that manages mock workers
 struct TestContext {

sgl-router/tests/test_openai_routing.rs

@@ -1,5 +1,13 @@
 //! Comprehensive integration tests for OpenAI backend functionality
 
+use std::{
+    collections::HashMap,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+};
+
 use axum::{
     body::Body,
     extract::Request,
@@ -26,13 +34,10 @@ use sglang_router_rs::{
     },
     routers::{openai::OpenAIRouter, RouterTrait},
 };
-use std::collections::HashMap;
-use std::sync::{
-    atomic::{AtomicUsize, Ordering},
-    Arc,
+use tokio::{
+    net::TcpListener,
+    time::{sleep, Duration},
 };
-use tokio::net::TcpListener;
-use tokio::time::{sleep, Duration};
 use tower::ServiceExt;
 
 mod common;
@@ -962,8 +967,7 @@ fn oracle_config_validation_accepts_wallet_alias() {
 /// Test that RouterManager delegates /v1/models to OpenAI router in single-router mode
 #[tokio::test]
 async fn test_router_manager_delegates_models_to_openai_router() {
-    use sglang_router_rs::routers::router_manager::RouterManager;
-    use sglang_router_rs::server::ServerConfig;
+    use sglang_router_rs::{routers::router_manager::RouterManager, server::ServerConfig};
 
     // Start a mock OpenAI server
     let mock_server = MockOpenAIServer::new().await;

sgl-router/tests/test_pd_routing.rs

@@ -1,12 +1,14 @@
 #[cfg(test)]
 mod test_pd_routing {
     use serde_json::json;
-    use sglang_router_rs::config::{
-        CircuitBreakerConfig, ConnectionMode, PolicyConfig, RetryConfig, RouterConfig, RoutingMode,
+    use sglang_router_rs::{
+        config::{
+            CircuitBreakerConfig, ConnectionMode, PolicyConfig, RetryConfig, RouterConfig,
+            RoutingMode,
+        },
+        core::{BasicWorkerBuilder, Worker, WorkerType},
+        routers::{http::pd_types::PDSelectionPolicy, RouterFactory},
     };
-    use sglang_router_rs::core::{BasicWorkerBuilder, Worker, WorkerType};
-    use sglang_router_rs::routers::http::pd_types::PDSelectionPolicy;
-    use sglang_router_rs::routers::RouterFactory;
 
     #[derive(Debug)]
     struct PDRequest {
@@ -201,14 +203,18 @@ mod test_pd_routing {
             };
 
             let app_context = {
-                use sglang_router_rs::core::{LoadMonitor, WorkerRegistry};
-                use sglang_router_rs::data_connector::{
-                    MemoryConversationItemStorage, MemoryConversationStorage, MemoryResponseStorage,
-                };
-                use sglang_router_rs::middleware::TokenBucket;
-                use sglang_router_rs::policies::PolicyRegistry;
                 use std::sync::{Arc, OnceLock};
 
+                use sglang_router_rs::{
+                    core::{LoadMonitor, WorkerRegistry},
+                    data_connector::{
+                        MemoryConversationItemStorage, MemoryConversationStorage,
+                        MemoryResponseStorage,
+                    },
+                    middleware::TokenBucket,
+                    policies::PolicyRegistry,
+                };
+
                 let client = reqwest::Client::new();
 
                 // Initialize rate limiter
@@ -421,6 +427,7 @@ mod test_pd_routing {
     #[tokio::test]
     async fn test_background_load_monitoring() {
         use std::collections::HashMap;
+
         use tokio::sync::watch;
 
         let (tx, rx) = watch::channel(HashMap::new());
@@ -466,6 +473,7 @@ mod test_pd_routing {
     #[tokio::test]
     async fn test_watch_channel_behavior() {
         use std::collections::HashMap;
+
         use tokio::sync::watch;
 
         let (tx, rx1) = watch::channel(HashMap::new());

sgl-router/tests/tokenizer_integration.rs

@@ -4,13 +4,13 @@
 //! implementation works correctly with real-world tokenizer files.
 
 mod common;
-use common::{ensure_tokenizer_cached, EXPECTED_HASHES, TEST_PROMPTS};
+use std::sync::Arc;
 
+use common::{ensure_tokenizer_cached, EXPECTED_HASHES, TEST_PROMPTS};
 use sglang_router_rs::tokenizer::{
     factory, huggingface::HuggingFaceTokenizer, sequence::Sequence, stop::*, stream::DecodeStream,
     traits::*,
 };
-use std::sync::Arc;
 
 const LONG_TEST_PROMPTS: [(&str, &str); 6] = [
     ("Tell me about the following text.", "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat."),
@@ -318,6 +318,7 @@ fn test_thread_safety() {
 #[test]
 fn test_chat_template_discovery() {
     use std::fs;
+
     use tempfile::TempDir;
 
     // Create a temporary directory with test files
@@ -366,6 +367,7 @@ fn test_chat_template_discovery() {
 #[test]
 fn test_load_chat_template_from_local_file() {
     use std::fs;
+
     use tempfile::TempDir;
 
     // Test 1: Load tokenizer with explicit chat template path