[model-gateway] change rust package name to sgl-model-gateway instead (#14283)

sgl-router/tests/api_endpoints_test.rs

@@ -10,7 +10,7 @@ use axum::{
 use common::mock_worker::{HealthStatus, MockWorker, MockWorkerConfig, WorkerType};
 use reqwest::Client;
 use serde_json::json;
-use sglang_router_rs::{
+use sgl_model_gateway::{
     app_context::AppContext,
     config::{RouterConfig, RoutingMode},
     core::Job,
@@ -1028,7 +1028,7 @@ mod responses_endpoint_tests {
         let app = ctx.create_app().await;
 
         // Directly store a response in the storage to test the retrieval endpoint
-        use sglang_router_rs::data_connector::{ResponseId, StoredResponse};
+        use sgl_model_gateway::data_connector::{ResponseId, StoredResponse};
         let mut stored_response = StoredResponse::new(None);
         stored_response.id = ResponseId::from("resp_test_input_items");
         stored_response.input = json!([

sgl-router/tests/cache_aware_backward_compat_test.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashMap, sync::Arc};
 
-use sglang_router_rs::{
+use sgl_model_gateway::{
     core::{BasicWorkerBuilder, Worker, WorkerType},
     policies::{CacheAwareConfig, CacheAwarePolicy, LoadBalancingPolicy},
 };

sgl-router/tests/chat_template_format_detection.rs

@@ -1,4 +1,4 @@
-use sglang_router_rs::{
+use sgl_model_gateway::{
     protocols::chat::{ChatMessage, MessageContent},
     tokenizer::chat_template::{
         detect_chat_template_content_format, ChatTemplateContentFormat, ChatTemplateParams,

sgl-router/tests/chat_template_integration.rs

@@ -1,4 +1,4 @@
-use sglang_router_rs::{
+use sgl_model_gateway::{
     protocols::{
         chat::{ChatMessage, MessageContent},
         common::{ContentPart, ImageUrl},

sgl-router/tests/chat_template_loading.rs

@@ -2,7 +2,7 @@
 mod tests {
     use std::fs;
 
-    use sglang_router_rs::{
+    use sgl_model_gateway::{
         protocols::chat::{ChatMessage, MessageContent},
         tokenizer::{chat_template::ChatTemplateParams, huggingface::HuggingFaceTokenizer},
     };
@@ -78,7 +78,7 @@ mod tests {
             .map(|msg| serde_json::to_value(msg).unwrap())
             .collect();
 
-        use sglang_router_rs::tokenizer::chat_template::ChatTemplateParams;
+        use sgl_model_gateway::tokenizer::chat_template::ChatTemplateParams;
         let params = ChatTemplateParams {
             add_generation_prompt: true,
             ..Default::default()

sgl-router/tests/common/mod.rs

@@ -14,7 +14,7 @@ use std::{
 };
 
 use serde_json::json;
-use sglang_router_rs::{
+use sgl_model_gateway::{
     app_context::AppContext,
     config::RouterConfig,
     core::{LoadMonitor, WorkerRegistry},
@@ -90,8 +90,8 @@ pub async fn create_test_context(config: RouterConfig) -> Arc<AppContext> {
 
     // Initialize JobQueue after AppContext is created
     let weak_context = Arc::downgrade(&app_context);
-    let job_queue = sglang_router_rs::core::JobQueue::new(
-        sglang_router_rs::core::JobQueueConfig::default(),
+    let job_queue = sgl_model_gateway::core::JobQueue::new(
+        sgl_model_gateway::core::JobQueueConfig::default(),
         weak_context,
     );
     app_context
@@ -100,7 +100,7 @@ pub async fn create_test_context(config: RouterConfig) -> Arc<AppContext> {
         .expect("JobQueue should only be initialized once");
 
     // Initialize WorkflowEngine and register workflows
-    use sglang_router_rs::core::workflow::{
+    use sgl_model_gateway::core::workflow::{
         create_worker_registration_workflow, create_worker_removal_workflow, WorkflowEngine,
     };
     let engine = Arc::new(WorkflowEngine::new());
@@ -112,7 +112,7 @@ pub async fn create_test_context(config: RouterConfig) -> Arc<AppContext> {
         .expect("WorkflowEngine should only be initialized once");
 
     // Initialize MCP manager with empty config
-    use sglang_router_rs::mcp::{McpConfig, McpManager};
+    use sgl_model_gateway::mcp::{McpConfig, McpManager};
     let empty_config = McpConfig {
         servers: vec![],
         pool: Default::default(),
@@ -137,7 +137,7 @@ pub async fn create_test_context_with_mcp_config(
     config: RouterConfig,
     mcp_config_path: &str,
 ) -> Arc<AppContext> {
-    use sglang_router_rs::mcp::{McpConfig, McpManager};
+    use sgl_model_gateway::mcp::{McpConfig, McpManager};
 
     let client = reqwest::Client::new();
 
@@ -201,8 +201,8 @@ pub async fn create_test_context_with_mcp_config(
 
     // Initialize JobQueue after AppContext is created
     let weak_context = Arc::downgrade(&app_context);
-    let job_queue = sglang_router_rs::core::JobQueue::new(
-        sglang_router_rs::core::JobQueueConfig::default(),
+    let job_queue = sgl_model_gateway::core::JobQueue::new(
+        sgl_model_gateway::core::JobQueueConfig::default(),
         weak_context,
     );
     app_context
@@ -211,7 +211,7 @@ pub async fn create_test_context_with_mcp_config(
         .expect("JobQueue should only be initialized once");
 
     // Initialize WorkflowEngine and register workflows
-    use sglang_router_rs::core::workflow::{
+    use sgl_model_gateway::core::workflow::{
         create_worker_registration_workflow, create_worker_removal_workflow, WorkflowEngine,
     };
     let engine = Arc::new(WorkflowEngine::new());

sgl-router/tests/common/test_app.rs

@@ -2,7 +2,7 @@ use std::sync::{Arc, OnceLock};
 
 use axum::Router;
 use reqwest::Client;
-use sglang_router_rs::{
+use sgl_model_gateway::{
     app_context::AppContext,
     config::RouterConfig,
     core::{LoadMonitor, WorkerRegistry},

sgl-router/tests/mcp_test.rs

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

sgl-router/tests/metrics_aggregator_test.rs

@@ -1,4 +1,4 @@
-use sglang_router_rs::core::metrics_aggregator::{aggregate_metrics, MetricPack};
+use sgl_model_gateway::core::metrics_aggregator::{aggregate_metrics, MetricPack};
 
 #[test]
 fn test_aggregate_simple() {

sgl-router/tests/policy_registry_integration.rs

@@ -2,7 +2,7 @@
 
 use std::{collections::HashMap, sync::Arc};
 
-use sglang_router_rs::{
+use sgl_model_gateway::{
     config::PolicyConfig, core::WorkerRegistry, policies::PolicyRegistry,
     protocols::worker_spec::WorkerConfigRequest, routers::router_manager::RouterManager,
 };
@@ -115,7 +115,7 @@ async fn test_policy_registry_with_router_manager() {
 
 #[test]
 fn test_policy_registry_cleanup() {
-    use sglang_router_rs::{config::PolicyConfig, policies::PolicyRegistry};
+    use sgl_model_gateway::{config::PolicyConfig, policies::PolicyRegistry};
 
     let registry = PolicyRegistry::new(PolicyConfig::RoundRobin);
 
@@ -142,7 +142,7 @@ fn test_policy_registry_cleanup() {
 
 #[test]
 fn test_policy_registry_multiple_models() {
-    use sglang_router_rs::{config::PolicyConfig, policies::PolicyRegistry};
+    use sgl_model_gateway::{config::PolicyConfig, policies::PolicyRegistry};
 
     let registry = PolicyRegistry::new(PolicyConfig::RoundRobin);
 

sgl-router/tests/request_formats_test.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use common::mock_worker::{HealthStatus, MockWorker, MockWorkerConfig, WorkerType};
 use reqwest::Client;
 use serde_json::json;
-use sglang_router_rs::{
+use sgl_model_gateway::{
     config::{RouterConfig, RoutingMode},
     routers::{RouterFactory, RouterTrait},
 };

sgl-router/tests/responses_api_test.rs

@@ -1,7 +1,7 @@
 // Integration test for Responses API
 
 use axum::http::StatusCode;
-use sglang_router_rs::protocols::{
+use sgl_model_gateway::protocols::{
     common::{GenerationRequest, ToolChoice, ToolChoiceValue, UsageInfo},
     responses::{
         ReasoningEffort, ResponseInput, ResponseReasoningParam, ResponseTool, ResponseToolType,
@@ -14,7 +14,7 @@ use common::{
     mock_mcp_server::MockMCPServer,
     mock_worker::{HealthStatus, MockWorker, MockWorkerConfig, WorkerType},
 };
-use sglang_router_rs::{config::RouterConfig, routers::RouterFactory};
+use sgl_model_gateway::{config::RouterConfig, routers::RouterFactory};
 
 #[tokio::test]
 async fn test_non_streaming_mcp_minimal_e2e_with_persistence() {
@@ -393,7 +393,7 @@ fn test_usage_conversion() {
         completion_tokens: 25,
         total_tokens: 40,
         reasoning_tokens: Some(8),
-        prompt_tokens_details: Some(sglang_router_rs::protocols::common::PromptTokenUsageInfo {
+        prompt_tokens_details: Some(sgl_model_gateway::protocols::common::PromptTokenUsageInfo {
             cached_tokens: 3,
         }),
     };
@@ -781,7 +781,7 @@ async fn test_max_tool_calls_limit() {
 async fn setup_streaming_mcp_test() -> (
     MockMCPServer,
     MockWorker,
-    Box<dyn sglang_router_rs::routers::RouterTrait>,
+    Box<dyn sgl_model_gateway::routers::RouterTrait>,
     tempfile::TempDir,
 ) {
     let mcp = MockMCPServer::start().await.expect("start mcp");

sgl-router/tests/spec/chat_completion.rs

@@ -1,5 +1,5 @@
 use serde_json::json;
-use sglang_router_rs::protocols::{
+use sgl_model_gateway::protocols::{
     chat::{ChatCompletionRequest, ChatMessage, MessageContent},
     common::{
         Function, FunctionCall, FunctionChoice, StreamOptions, Tool, ToolChoice, ToolChoiceValue,

sgl-router/tests/spec/chat_message.rs

@@ -1,5 +1,5 @@
 use serde_json::json;
-use sglang_router_rs::protocols::chat::{ChatMessage, MessageContent};
+use sgl_model_gateway::protocols::chat::{ChatMessage, MessageContent};
 
 #[test]
 fn test_chat_message_tagged_by_role_system() {

sgl-router/tests/spec/embedding.rs

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

sgl-router/tests/spec/rerank.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use serde_json::{from_str, to_string, Number, Value};
-use sglang_router_rs::protocols::{
+use sgl_model_gateway::protocols::{
     common::{GenerationRequest, StringOrArray, UsageInfo},
     rerank::{RerankRequest, RerankResponse, RerankResult, V1RerankReqInput},
 };

sgl-router/tests/spec/responses.rs

@@ -1,5 +1,5 @@
 use serde_json::json;
-use sglang_router_rs::protocols::{
+use sgl_model_gateway::protocols::{
     common::{Function, StringOrArray, ToolChoice, ToolChoiceValue},
     responses::{
         IncludeField, ResponseInput, ResponseInputOutputItem, ResponseTool, ResponseToolType,
@@ -963,7 +963,7 @@ fn test_validate_input_items_structure() {
 /// Test tool_choice defaults to auto when tools are present
 #[test]
 fn test_normalize_tool_choice_auto() {
-    use sglang_router_rs::protocols::validated::Normalizable;
+    use sgl_model_gateway::protocols::validated::Normalizable;
 
     let mut request = ResponsesRequest {
         input: ResponseInput::Text("test".to_string()),
@@ -1004,7 +1004,7 @@ fn test_normalize_tool_choice_auto() {
 /// Test tool_choice defaults to none when tools array is empty
 #[test]
 fn test_normalize_tool_choice_none() {
-    use sglang_router_rs::protocols::validated::Normalizable;
+    use sgl_model_gateway::protocols::validated::Normalizable;
 
     let mut request = ResponsesRequest {
         input: ResponseInput::Text("test".to_string()),
@@ -1031,7 +1031,7 @@ fn test_normalize_tool_choice_none() {
 /// Test tool_choice is not overridden if already set
 #[test]
 fn test_normalize_tool_choice_no_override() {
-    use sglang_router_rs::protocols::validated::Normalizable;
+    use sgl_model_gateway::protocols::validated::Normalizable;
 
     let mut request = ResponsesRequest {
         input: ResponseInput::Text("test".to_string()),
@@ -1068,7 +1068,7 @@ fn test_normalize_tool_choice_no_override() {
 /// Test parallel_tool_calls defaults to true when tools are present
 #[test]
 fn test_normalize_parallel_tool_calls() {
-    use sglang_router_rs::protocols::validated::Normalizable;
+    use sgl_model_gateway::protocols::validated::Normalizable;
 
     let mut request = ResponsesRequest {
         input: ResponseInput::Text("test".to_string()),
@@ -1107,7 +1107,7 @@ fn test_normalize_parallel_tool_calls() {
 /// Test parallel_tool_calls is not set when tools are absent
 #[test]
 fn test_normalize_parallel_tool_calls_no_tools() {
-    use sglang_router_rs::protocols::validated::Normalizable;
+    use sgl_model_gateway::protocols::validated::Normalizable;
 
     let mut request = ResponsesRequest {
         input: ResponseInput::Text("test".to_string()),
@@ -1127,7 +1127,7 @@ fn test_normalize_parallel_tool_calls_no_tools() {
 /// Test parallel_tool_calls is not overridden if already set
 #[test]
 fn test_normalize_parallel_tool_calls_no_override() {
-    use sglang_router_rs::protocols::validated::Normalizable;
+    use sgl_model_gateway::protocols::validated::Normalizable;
 
     let mut request = ResponsesRequest {
         input: ResponseInput::Text("test".to_string()),
@@ -1162,7 +1162,7 @@ fn test_normalize_parallel_tool_calls_no_override() {
 /// Test store defaults to true
 #[test]
 fn test_normalize_store_default() {
-    use sglang_router_rs::protocols::validated::Normalizable;
+    use sgl_model_gateway::protocols::validated::Normalizable;
 
     let mut request = ResponsesRequest {
         input: ResponseInput::Text("test".to_string()),
@@ -1182,7 +1182,7 @@ fn test_normalize_store_default() {
 /// Test store is not overridden if already set
 #[test]
 fn test_normalize_store_no_override() {
-    use sglang_router_rs::protocols::validated::Normalizable;
+    use sgl_model_gateway::protocols::validated::Normalizable;
 
     let mut request = ResponsesRequest {
         input: ResponseInput::Text("test".to_string()),

sgl-router/tests/streaming_tests.rs

@@ -6,7 +6,7 @@ use common::mock_worker::{HealthStatus, MockWorker, MockWorkerConfig, WorkerType
 use futures_util::StreamExt;
 use reqwest::Client;
 use serde_json::json;
-use sglang_router_rs::{
+use sgl_model_gateway::{
     config::{RouterConfig, RoutingMode},
     routers::{RouterFactory, RouterTrait},
 };

sgl-router/tests/test_openai_routing.rs

@@ -17,7 +17,7 @@ use axum::{
     Json, Router,
 };
 use serde_json::json;
-use sglang_router_rs::{
+use sgl_model_gateway::{
     config::{
         ConfigError, ConfigValidator, HistoryBackend, OracleConfig, RouterConfig, RoutingMode,
     },
@@ -577,12 +577,14 @@ async fn test_router_factory_openai_mode() {
         worker_urls: vec!["https://api.openai.com".to_string()],
     };
 
-    let router_config =
-        RouterConfig::new(routing_mode, sglang_router_rs::config::PolicyConfig::Random);
+    let router_config = RouterConfig::new(
+        routing_mode,
+        sgl_model_gateway::config::PolicyConfig::Random,
+    );
 
     let app_context = common::create_test_context(router_config).await;
 
-    let router = sglang_router_rs::routers::RouterFactory::create_router(&app_context).await;
+    let router = sgl_model_gateway::routers::RouterFactory::create_router(&app_context).await;
     assert!(
         router.is_ok(),
         "Router factory should create OpenAI router successfully"

sgl-router/tests/test_pd_routing.rs

@@ -1,7 +1,7 @@
 #[cfg(test)]
 mod test_pd_routing {
     use serde_json::json;
-    use sglang_router_rs::{
+    use sgl_model_gateway::{
         app_context::AppContext,
         config::{PolicyConfig, RouterConfig, RoutingMode},
         core::{BasicWorkerBuilder, Worker, WorkerType},
@@ -38,7 +38,7 @@ mod test_pd_routing {
 
     #[test]
     fn test_worker_types() {
-        use sglang_router_rs::core::{BasicWorkerBuilder, Worker, WorkerType};
+        use sgl_model_gateway::core::{BasicWorkerBuilder, Worker, WorkerType};
 
         let prefill_worker: Box<dyn Worker> = Box::new(
             BasicWorkerBuilder::new("http://prefill:8080")
@@ -214,7 +214,7 @@ mod test_pd_routing {
             let app_context = {
                 use std::sync::{Arc, OnceLock};
 
-                use sglang_router_rs::{
+                use sgl_model_gateway::{
                     core::{LoadMonitor, WorkerRegistry},
                     data_connector::{
                         MemoryConversationItemStorage, MemoryConversationStorage,
@@ -673,7 +673,7 @@ mod test_pd_routing {
 
     #[test]
     fn test_bootstrap_injection_with_benchmark_requests() {
-        use sglang_router_rs::core::{BasicWorkerBuilder, Worker, WorkerType};
+        use sgl_model_gateway::core::{BasicWorkerBuilder, Worker, WorkerType};
 
         let mut benchmark_request = json!({
             "input_ids": vec![vec![1, 2, 3, 4]; 16], // Batch size 16

sgl-router/tests/tokenizer_cache_correctness_test.rs

@@ -9,7 +9,7 @@ use std::{
     sync::{Arc, OnceLock},
 };
 
-use sglang_router_rs::tokenizer::{
+use sgl_model_gateway::tokenizer::{
     cache::{CacheConfig, CachedTokenizer},
     hub::download_tokenizer_from_hf,
     huggingface::HuggingFaceTokenizer,

sgl-router/tests/tokenizer_integration.rs

@@ -7,7 +7,7 @@ mod common;
 use std::sync::Arc;
 
 use common::{ensure_tokenizer_cached, EXPECTED_HASHES, TEST_PROMPTS};
-use sglang_router_rs::tokenizer::{
+use sgl_model_gateway::tokenizer::{
     factory, huggingface::HuggingFaceTokenizer, sequence::Sequence, stop::*, stream::DecodeStream,
     traits::*,
 };
@@ -269,7 +269,7 @@ fn test_batch_encoding() {
 
 #[test]
 fn test_special_tokens() {
-    use sglang_router_rs::tokenizer::traits::Tokenizer as TokenizerTrait;
+    use sgl_model_gateway::tokenizer::traits::Tokenizer as TokenizerTrait;
 
     let tokenizer_path = ensure_tokenizer_cached();
     let tokenizer = HuggingFaceTokenizer::from_file(tokenizer_path.to_str().unwrap())
@@ -398,7 +398,7 @@ fn test_load_chat_template_from_local_file() {
 
 #[tokio::test]
 async fn test_tinyllama_embedded_template() {
-    use sglang_router_rs::tokenizer::hub::download_tokenizer_from_hf;
+    use sgl_model_gateway::tokenizer::hub::download_tokenizer_from_hf;
 
     // Skip in CI without HF_TOKEN
 
@@ -434,7 +434,7 @@ async fn test_tinyllama_embedded_template() {
 
 #[tokio::test]
 async fn test_qwen3_next_embedded_template() {
-    use sglang_router_rs::tokenizer::hub::download_tokenizer_from_hf;
+    use sgl_model_gateway::tokenizer::hub::download_tokenizer_from_hf;
 
     // Test 3: Qwen3-Next has chat template in tokenizer_config.json
     match download_tokenizer_from_hf("Qwen/Qwen3-Next-80B-A3B-Instruct").await {
@@ -466,7 +466,7 @@ async fn test_qwen3_next_embedded_template() {
 
 #[tokio::test]
 async fn test_qwen3_vl_json_template_priority() {
-    use sglang_router_rs::tokenizer::hub::download_tokenizer_from_hf;
+    use sgl_model_gateway::tokenizer::hub::download_tokenizer_from_hf;
 
     // Test 4: Qwen3-VL has both tokenizer_config.json template and chat_template.json
     // Should prioritize chat_template.json
@@ -508,7 +508,7 @@ async fn test_qwen3_vl_json_template_priority() {
 
 #[tokio::test]
 async fn test_llava_separate_jinja_template() {
-    use sglang_router_rs::tokenizer::hub::download_tokenizer_from_hf;
+    use sgl_model_gateway::tokenizer::hub::download_tokenizer_from_hf;
 
     // Test 5: llava has chat_template.jinja as a separate file, not in tokenizer_config.json
     match download_tokenizer_from_hf("llava-hf/llava-1.5-7b-hf").await {

sgl-router/tests/tool_parser_deepseek.rs

@@ -1,6 +1,6 @@
 //! DeepSeek V3 Parser Integration Tests
 
-use sglang_router_rs::tool_parser::{DeepSeekParser, ToolParser};
+use sgl_model_gateway::tool_parser::{DeepSeekParser, ToolParser};
 
 mod common;
 use common::create_test_tools;

sgl-router/tests/tool_parser_edge_cases.rs

@@ -2,7 +2,7 @@
 //!
 //! Tests for malformed input, edge cases, and error recovery
 
-use sglang_router_rs::tool_parser::{
+use sgl_model_gateway::tool_parser::{
     JsonParser, MistralParser, PythonicParser, QwenParser, ToolParser,
 };
 

sgl-router/tests/tool_parser_fallback.rs

@@ -3,7 +3,7 @@
 //! When tool call parsing fails, the original text should be preserved as normal text
 //! rather than being lost. This ensures graceful degradation.
 
-use sglang_router_rs::tool_parser::{
+use sgl_model_gateway::tool_parser::{
     DeepSeekParser, JsonParser, LlamaParser, MistralParser, QwenParser, ToolParser,
 };
 

sgl-router/tests/tool_parser_glm4_moe.rs

@@ -1,6 +1,6 @@
 //! GLM-4 MoE Parser Integration Tests
 
-use sglang_router_rs::tool_parser::{Glm4MoeParser, ToolParser};
+use sgl_model_gateway::tool_parser::{Glm4MoeParser, ToolParser};
 
 mod common;
 use common::create_test_tools;

sgl-router/tests/tool_parser_json.rs

@@ -3,7 +3,7 @@
 //! Tests for the JSON parser which handles OpenAI, Claude, and generic JSON formats
 
 use serde_json::json;
-use sglang_router_rs::tool_parser::{JsonParser, ToolParser};
+use sgl_model_gateway::tool_parser::{JsonParser, ToolParser};
 
 mod common;
 use common::{create_test_tools, streaming_helpers::*};
@@ -166,7 +166,7 @@ async fn test_json_format_detection() {
 // Streaming tests for JSON array format
 #[tokio::test]
 async fn test_json_array_streaming_required_mode() {
-    use sglang_router_rs::protocols::common::Tool;
+    use sgl_model_gateway::protocols::common::Tool;
 
     // Test that simulates the exact streaming pattern from required mode
     let mut parser = JsonParser::new();
@@ -174,7 +174,7 @@ async fn test_json_array_streaming_required_mode() {
     // Define test tools
     let tools = vec![Tool {
         tool_type: "function".to_string(),
-        function: sglang_router_rs::protocols::common::Function {
+        function: sgl_model_gateway::protocols::common::Function {
             name: "get_weather".to_string(),
             description: Some("Get weather".to_string()),
             parameters: serde_json::json!({}),
@@ -240,7 +240,7 @@ async fn test_json_array_streaming_required_mode() {
 
 #[tokio::test]
 async fn test_json_array_multiple_tools_streaming() {
-    use sglang_router_rs::protocols::common::Tool;
+    use sgl_model_gateway::protocols::common::Tool;
 
     // Test with multiple tools in array
     let mut parser = JsonParser::new();
@@ -248,7 +248,7 @@ async fn test_json_array_multiple_tools_streaming() {
     let tools = vec![
         Tool {
             tool_type: "function".to_string(),
-            function: sglang_router_rs::protocols::common::Function {
+            function: sgl_model_gateway::protocols::common::Function {
                 name: "get_weather".to_string(),
                 description: Some("Get weather".to_string()),
                 parameters: serde_json::json!({}),
@@ -257,7 +257,7 @@ async fn test_json_array_multiple_tools_streaming() {
         },
         Tool {
             tool_type: "function".to_string(),
-            function: sglang_router_rs::protocols::common::Function {
+            function: sgl_model_gateway::protocols::common::Function {
                 name: "get_news".to_string(),
                 description: Some("Get news".to_string()),
                 parameters: serde_json::json!({}),
@@ -305,14 +305,14 @@ async fn test_json_array_multiple_tools_streaming() {
 
 #[tokio::test]
 async fn test_json_array_closing_bracket_separate_chunk() {
-    use sglang_router_rs::protocols::common::Tool;
+    use sgl_model_gateway::protocols::common::Tool;
 
     // Test case where the closing ] comes as a separate chunk
     let mut parser = JsonParser::new();
 
     let tools = vec![Tool {
         tool_type: "function".to_string(),
-        function: sglang_router_rs::protocols::common::Function {
+        function: sgl_model_gateway::protocols::common::Function {
             name: "get_weather".to_string(),
             description: Some("Get weather".to_string()),
             parameters: json!({}),
@@ -366,14 +366,14 @@ async fn test_json_array_closing_bracket_separate_chunk() {
 
 #[tokio::test]
 async fn test_json_single_object_with_trailing_text() {
-    use sglang_router_rs::protocols::common::Tool;
+    use sgl_model_gateway::protocols::common::Tool;
 
     // Test single object format (no array) with trailing text
     let mut parser = JsonParser::new();
 
     let tools = vec![Tool {
         tool_type: "function".to_string(),
-        function: sglang_router_rs::protocols::common::Function {
+        function: sgl_model_gateway::protocols::common::Function {
             name: "get_weather".to_string(),
             description: Some("Get weather".to_string()),
             parameters: serde_json::json!({}),
@@ -420,14 +420,14 @@ async fn test_json_single_object_with_trailing_text() {
 
 #[tokio::test]
 async fn test_json_single_object_with_bracket_in_text() {
-    use sglang_router_rs::protocols::common::Tool;
+    use sgl_model_gateway::protocols::common::Tool;
 
     // Test that ] in normal text is NOT stripped for single object format
     let mut parser = JsonParser::new();
 
     let tools = vec![Tool {
         tool_type: "function".to_string(),
-        function: sglang_router_rs::protocols::common::Function {
+        function: sgl_model_gateway::protocols::common::Function {
             name: "get_weather".to_string(),
             description: Some("Get weather".to_string()),
             parameters: serde_json::json!({}),
@@ -472,14 +472,14 @@ async fn test_json_single_object_with_bracket_in_text() {
 
 #[tokio::test]
 async fn test_json_array_bracket_in_text_after_tools() {
-    use sglang_router_rs::protocols::common::Tool;
+    use sgl_model_gateway::protocols::common::Tool;
 
     // Test that ] in normal text AFTER array tools is preserved
     let mut parser = JsonParser::new();
 
     let tools = vec![Tool {
         tool_type: "function".to_string(),
-        function: sglang_router_rs::protocols::common::Function {
+        function: sgl_model_gateway::protocols::common::Function {
             name: "get_weather".to_string(),
             description: Some("Get weather".to_string()),
             parameters: serde_json::json!({}),

sgl-router/tests/tool_parser_kimik2.rs

@@ -1,6 +1,6 @@
 //! Kimi K2 Parser Integration Tests
 
-use sglang_router_rs::tool_parser::{KimiK2Parser, ToolParser};
+use sgl_model_gateway::tool_parser::{KimiK2Parser, ToolParser};
 
 mod common;
 use common::create_test_tools;

sgl-router/tests/tool_parser_llama.rs

@@ -2,7 +2,7 @@
 //!
 //! Tests for the Llama parser which handles <|python_tag|> format and plain JSON
 
-use sglang_router_rs::tool_parser::{LlamaParser, ToolParser};
+use sgl_model_gateway::tool_parser::{LlamaParser, ToolParser};
 
 mod common;
 use common::{create_test_tools, streaming_helpers::*};

sgl-router/tests/tool_parser_minimax_m2.rs

@@ -1,6 +1,6 @@
 //! MiniMax M2 Parser Integration Tests
 
-use sglang_router_rs::tool_parser::{MinimaxM2Parser, ToolParser};
+use sgl_model_gateway::tool_parser::{MinimaxM2Parser, ToolParser};
 
 mod common;
 use common::create_test_tools;

sgl-router/tests/tool_parser_mistral.rs

@@ -3,7 +3,7 @@
 //! Tests for the Mistral parser which handles [TOOL_CALLS] format
 
 use serde_json::json;
-use sglang_router_rs::tool_parser::{MistralParser, ToolParser};
+use sgl_model_gateway::tool_parser::{MistralParser, ToolParser};
 
 #[tokio::test]
 async fn test_mistral_single_tool() {
@@ -158,14 +158,14 @@ Let me execute these searches for you."#;
 
 #[tokio::test]
 async fn test_mistral_streaming_closing_bracket() {
-    use sglang_router_rs::protocols::common::Tool;
+    use sgl_model_gateway::protocols::common::Tool;
 
     // Test that closing ] is stripped for Mistral array format
     let mut parser = MistralParser::new();
 
     let tools = vec![Tool {
         tool_type: "function".to_string(),
-        function: sglang_router_rs::protocols::common::Function {
+        function: sgl_model_gateway::protocols::common::Function {
             name: "get_weather".to_string(),
             description: Some("Get weather".to_string()),
             parameters: json!({}),
@@ -218,14 +218,14 @@ async fn test_mistral_streaming_closing_bracket() {
 
 #[tokio::test]
 async fn test_mistral_streaming_bracket_in_text_after_tools() {
-    use sglang_router_rs::protocols::common::Tool;
+    use sgl_model_gateway::protocols::common::Tool;
 
     // Test that ] in normal text AFTER tool calls is preserved
     let mut parser = MistralParser::new();
 
     let tools = vec![Tool {
         tool_type: "function".to_string(),
-        function: sglang_router_rs::protocols::common::Function {
+        function: sgl_model_gateway::protocols::common::Function {
             name: "get_weather".to_string(),
             description: Some("Get weather".to_string()),
             parameters: json!({}),

sgl-router/tests/tool_parser_mixed_edge_cases.rs

@@ -3,7 +3,7 @@
 //! Tests for edge cases across parsers and mixed format scenarios
 
 use serde_json::json;
-use sglang_router_rs::tool_parser::{
+use sgl_model_gateway::tool_parser::{
     JsonParser, LlamaParser, MistralParser, PythonicParser, QwenParser, ToolParser,
 };
 

sgl-router/tests/tool_parser_partial_json.rs

@@ -2,7 +2,7 @@
 //!
 //! Tests for the partial JSON parser with allow_partial_strings flag behavior
 
-use sglang_router_rs::tool_parser::partial_json::PartialJson;
+use sgl_model_gateway::tool_parser::partial_json::PartialJson;
 
 #[test]
 fn test_partial_string_flag_disallows_incomplete_strings() {

sgl-router/tests/tool_parser_pythonic.rs

@@ -3,7 +3,7 @@
 //! Tests for the Pythonic parser which handles Python function call syntax
 
 use serde_json::json;
-use sglang_router_rs::tool_parser::{PythonicParser, ToolParser};
+use sgl_model_gateway::tool_parser::{PythonicParser, ToolParser};
 
 mod common;
 use common::create_test_tools;

sgl-router/tests/tool_parser_qwen.rs

@@ -3,7 +3,7 @@
 //! Tests for the Qwen parser which handles <tool_call>...</tool_call> format
 
 use serde_json::json;
-use sglang_router_rs::tool_parser::{QwenParser, ToolParser};
+use sgl_model_gateway::tool_parser::{QwenParser, ToolParser};
 
 mod common;
 use common::{create_test_tools, streaming_helpers::*};

sgl-router/tests/tool_parser_step3.rs

@@ -1,6 +1,6 @@
 //! Step3 Parser Integration Tests
 
-use sglang_router_rs::tool_parser::{Step3Parser, ToolParser};
+use sgl_model_gateway::tool_parser::{Step3Parser, ToolParser};
 
 mod common;
 use common::create_test_tools;

sgl-router/tests/workflow_test.rs

@@ -8,7 +8,7 @@ use std::{
     time::Duration,
 };
 
-use sglang_router_rs::core::workflow::*;
+use sgl_model_gateway::core::workflow::*;
 use tokio::time::sleep;
 
 // Test step that counts invocations