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

Author: slin1237

sgl-router/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "sglang-router"
+name = "sgl-model-gateway"
 version = "0.2.3"
 edition = "2021"
 
@@ -11,12 +11,11 @@ vendored-openssl = ["openssl/vendored"]
 unused_qualifications = "warn"
 
 [lib]
-name = "sglang_router_rs"
-# Pure Rust library (rlib for the binary and other Rust dependents)
+name = "sgl_model_gateway"
 crate-type = ["rlib"]
 
 [[bin]]
-name = "sglang-router"
+name = "sgl-model-gateway"
 path = "src/main.rs"
 
 [[bin]]

sgl-router/README.md

@@ -93,20 +93,28 @@ pip install --force-reinstall dist/*.whl
 After installation, verify the installation and check version information:
 
 ```bash
-# Short version info (Rust binary)
-./target/release/sglang-router -v
-
-# Full version info with build details (Rust binary)
-./target/release/sglang-router --version
+# Simple version (Rust binary)
+./target/release/sgl-model-gateway --version
+# or use aliases
+./target/release/smg --version
+./target/release/amg --version
+
+# Full version info with build details
+./target/release/sgl-model-gateway --version-verbose
+
+# Python CLI
+amg --version
+amg --version-verbose
+python3 -m sglang_router --version
 ```
 
-The `-v` flag displays a concise version string, while `--version` (or `-V`) shows comprehensive build information including Git commit, build time, compiler versions, and platform details.
+The `--version` (or `-V`) flag displays the version string. Use `--version-verbose` for comprehensive build information including Git commit, build time, compiler versions, and platform details.
 
 ## Quick Start
 ### Regular HTTP Routing
 - **Rust binary**
   ```bash
-  ./target/release/sglang-router \
+  ./target/release/sgl-model-gateway \
     --worker-urls http://worker1:8000 http://worker2:8000 \
     --policy cache_aware
   ```
@@ -121,7 +129,7 @@ The `-v` flag displays a concise version string, while `--version` (or `-V`) sho
 ### Prefill/Decode Disaggregation (PD)
 - **Rust binary**
   ```bash
-  ./target/release/sglang-router \
+  ./target/release/sgl-model-gateway \
     --pd-disaggregation \
     --prefill http://prefill1:30001 9001 \
     --prefill http://prefill2:30002 \
@@ -146,7 +154,7 @@ Prefill entries accept an optional bootstrap port. PD mode merges prefill metada
 ### Multi-Model Inference Gateway
 Enable IGW mode to route multiple models through a single router while applying per-model policies:
 ```bash
-./target/release/sglang-router \
+./target/release/sgl-model-gateway \
   --enable-igw \
   --policy cache_aware \
   --max-concurrent-requests 512
@@ -194,7 +202,7 @@ Add more workers with the same API; include optional `labels` (for per-model pol
 ### gRPC Routing
 - **Rust binary**
   ```bash
-  ./target/release/sglang-router \
+  ./target/release/sgl-model-gateway \
     --worker-urls grpc://worker-grpc-0:31001 grpc://worker-grpc-1:31002 \
     --tokenizer-path /path/to/tokenizer.json \
     --reasoning-parser deepseek-r1 \
@@ -229,15 +237,15 @@ python3 -m sglang_router.launch_router \
 **Notes**
 - OpenAI backend mode acts as a proxy to a single remote endpoint; load balancing is not applied.
 - Provide exactly one `--worker-urls` entry per router instance.
-- The Rust binary supports the same flags (`./target/release/sglang-router --backend openai ...`).
+- The Rust binary supports the same flags (`./target/release/sgl-model-gateway --backend openai ...`).
 
 ### MCP Integration
 The SGL Model Gateway provides native Model Context Protocol (MCP) client integration, enabling tool calling across STDIO, SSE, and Streamable transports. MCP servers are configured via a YAML configuration file and registered at startup through the workflow engine.
 
 #### Basic Usage
 ```bash
 # Rust binary
-./target/release/sglang-router \
+./target/release/sgl-model-gateway \
   --mcp-config-path /path/to/mcp-config.yaml \
   --worker-urls http://worker1:8000
 
@@ -407,7 +415,7 @@ All administrative routes inherit router API-key protection when `--api-key` is
 ### Service Discovery
 Enable Kubernetes discovery to reconcile workers automatically:
 ```bash
-./target/release/sglang-router \
+./target/release/sgl-model-gateway \
   --service-discovery \
   --selector app=sglang-worker role=inference \
   --service-discovery-namespace sglang-system \

sgl-router/benches/request_processing.rs

@@ -2,7 +2,7 @@ use std::time::Instant;
 
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use serde_json::{from_str, to_string, to_value, to_vec};
-use sglang_router_rs::{
+use sgl_model_gateway::{
     core::{BasicWorker, BasicWorkerBuilder, Worker, WorkerType},
     protocols::{
         chat::{ChatCompletionRequest, ChatMessage, MessageContent},

sgl-router/benches/tokenizer_benchmark.rs

@@ -13,7 +13,7 @@ use std::{
 };
 
 use criterion::{black_box, criterion_group, BenchmarkId, Criterion, Throughput};
-use sglang_router_rs::tokenizer::{
+use sgl_model_gateway::tokenizer::{
     cache::{CacheConfig, CachedTokenizer},
     huggingface::HuggingFaceTokenizer,
     sequence::Sequence,
@@ -31,7 +31,7 @@ fn get_tokenizer_path() -> &'static PathBuf {
         // with special: true, normalized: false - perfect for demonstrating L1 cache
         let rt = tokio::runtime::Runtime::new().expect("Failed to create tokio runtime");
         let tokenizer_dir = rt.block_on(async {
-            sglang_router_rs::tokenizer::hub::download_tokenizer_from_hf(
+            sgl_model_gateway::tokenizer::hub::download_tokenizer_from_hf(
                 "Qwen/Qwen3-4B-Instruct-2507",
             )
             .await

sgl-router/benches/tool_parser_benchmark.rs

@@ -19,7 +19,7 @@ use std::{
 
 use criterion::{black_box, criterion_group, BenchmarkId, Criterion, Throughput};
 use serde_json::json;
-use sglang_router_rs::{
+use sgl_model_gateway::{
     protocols::common::{Function, Tool},
     tool_parser::{JsonParser, ParserFactory as ToolParserFactory, ToolParser},
 };

sgl-router/bindings/golang/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
-name = "sglang-router-golang"
-version = "0.2.2"
+name = "sgl-model-gateway-golang"
+version = "0.2.3"
 edition = "2021"
 
 [lib]
-name = "sglang_router_rs"
+name = "sgl_model_gateway_go"
 crate-type = ["cdylib"]
 
 [dependencies]
@@ -18,14 +18,13 @@ once_cell = "1.21.3"
 futures-util = "0.3"
 tracing = "0.1"
 
-[dependencies.sglang-router]
+[dependencies.sgl-model-gateway]
 path = "../.."
 default-features = true
-package = "sglang-router"
 
 [features]
 default = []
-vendored-openssl = ["sglang-router/vendored-openssl"]
+vendored-openssl = ["sgl-model-gateway/vendored-openssl"]
 
 [profile.release]
 opt-level = "z"     # Optimize for size

sgl-router/bindings/golang/src/client.rs

@@ -8,11 +8,11 @@ use tokio::runtime::Runtime;
 use once_cell::sync::Lazy;
 use uuid::Uuid;
 
-use sglang_router::tokenizer::create_tokenizer_from_file;
-use sglang_router::tokenizer::traits::Tokenizer;
-use sglang_router::grpc_client::sglang_scheduler::SglangSchedulerClient;
-use sglang_router::protocols::chat::ChatCompletionRequest;
-use sglang_router::routers::grpc::utils::{process_chat_messages, generate_tool_constraints};
+use sgl_model_gateway::tokenizer::create_tokenizer_from_file;
+use sgl_model_gateway::tokenizer::traits::Tokenizer;
+use sgl_model_gateway::grpc_client::sglang_scheduler::SglangSchedulerClient;
+use sgl_model_gateway::protocols::chat::ChatCompletionRequest;
+use sgl_model_gateway::routers::grpc::utils::{process_chat_messages, generate_tool_constraints};
 
 use super::error::{SglErrorCode, set_error_message};
 use super::grpc_converter::sgl_grpc_response_converter_create;

sgl-router/bindings/golang/src/grpc_converter.rs

@@ -9,22 +9,22 @@ use serde_json::Value;
 use tokio::runtime::Runtime;
 use once_cell::sync::Lazy;
 
-use sglang_router::tokenizer::traits::Tokenizer;
-use sglang_router::tokenizer::stream::DecodeStream;
-use sglang_router::tool_parser::ToolParser;
-use sglang_router::protocols::common::{Tool, ToolChoice, ToolChoiceValue, ToolCallDelta, FunctionCallDelta, Usage, StringOrArray};
-use sglang_router::tokenizer::stop::StopSequenceDecoder;
-use sglang_router::grpc_client::sglang_proto as proto;
+use sgl_model_gateway::tokenizer::traits::Tokenizer;
+use sgl_model_gateway::tokenizer::stream::DecodeStream;
+use sgl_model_gateway::tool_parser::ToolParser;
+use sgl_model_gateway::protocols::common::{Tool, ToolChoice, ToolChoiceValue, ToolCallDelta, FunctionCallDelta, Usage, StringOrArray};
+use sgl_model_gateway::tokenizer::stop::StopSequenceDecoder;
+use sgl_model_gateway::grpc_client::sglang_proto as proto;
 
 use super::error::{SglErrorCode, set_error_message, clear_error_message};
 use super::tokenizer::TokenizerHandle;
 use super::utils::generate_tool_call_id;
 
 /// Global parser factory (initialized once)
 // Use the re-exported ParserFactory from tool_parser module
-static PARSER_FACTORY: Lazy<sglang_router::tool_parser::ParserFactory> = Lazy::new(|| {
+static PARSER_FACTORY: Lazy<sgl_model_gateway::tool_parser::ParserFactory> = Lazy::new(|| {
     // ParserFactory is re-exported from tool_parser::factory, so we can use it directly
-    sglang_router::tool_parser::ParserFactory::default()
+    sgl_model_gateway::tool_parser::ParserFactory::default()
 });
 
 /// Global tokio runtime for async operations
@@ -151,7 +151,7 @@ pub unsafe extern "C" fn sgl_grpc_response_converter_create(
     // Create stop decoder if needed
     let stop_decoder = if stop.is_some() || stop_token_ids.is_some() {
         Some(Arc::new(tokio::sync::Mutex::new(
-            sglang_router::routers::grpc::utils::create_stop_decoder(
+            sgl_model_gateway::routers::grpc::utils::create_stop_decoder(
                 &tokenizer,
                 stop.as_ref(),
                 stop_token_ids.as_ref(),
@@ -389,9 +389,9 @@ pub(crate) async fn convert_proto_chunk_to_openai(
     request_id: &str,
     created: u64,
     system_fingerprint: Option<&str>,
-) -> Result<Option<sglang_router::protocols::chat::ChatCompletionStreamResponse>, String> {
-    use sglang_router::grpc_client::sglang_proto::generate_response::Response::*;
-    use sglang_router::protocols::chat::{ChatCompletionStreamResponse, ChatMessageDelta, ChatStreamChoice};
+) -> Result<Option<sgl_model_gateway::protocols::chat::ChatCompletionStreamResponse>, String> {
+    use sgl_model_gateway::grpc_client::sglang_proto::generate_response::Response::*;
+    use sgl_model_gateway::protocols::chat::{ChatCompletionStreamResponse, ChatMessageDelta, ChatStreamChoice};
 
     match proto_response.response {
         Some(Chunk(chunk)) => {
@@ -427,19 +427,19 @@ pub(crate) async fn convert_proto_chunk_to_openai(
                 let mut text = String::new();
                 for &token_id in &chunk.token_ids {
                     match decoder_guard.process_token(token_id).unwrap_or_else(|_| {
-                        sglang_router::tokenizer::stop::SequenceDecoderOutput::Held
+                        sgl_model_gateway::tokenizer::stop::SequenceDecoderOutput::Held
                     }) {
-                        sglang_router::tokenizer::stop::SequenceDecoderOutput::Text(t) => {
+                        sgl_model_gateway::tokenizer::stop::SequenceDecoderOutput::Text(t) => {
                             text.push_str(&t);
                         }
-                        sglang_router::tokenizer::stop::SequenceDecoderOutput::StoppedWithText(t) => {
+                        sgl_model_gateway::tokenizer::stop::SequenceDecoderOutput::StoppedWithText(t) => {
                             text.push_str(&t);
                             break;
                         }
-                        sglang_router::tokenizer::stop::SequenceDecoderOutput::Stopped => {
+                        sgl_model_gateway::tokenizer::stop::SequenceDecoderOutput::Stopped => {
                             break;
                         }
-                        sglang_router::tokenizer::stop::SequenceDecoderOutput::Held => {}
+                        sgl_model_gateway::tokenizer::stop::SequenceDecoderOutput::Held => {}
                     }
                 }
                 text

sgl-router/bindings/golang/src/stream.rs

@@ -23,7 +23,7 @@ use tokio::runtime::Runtime;
 use once_cell::sync::Lazy;
 use futures_util::StreamExt;
 
-use sglang_router::grpc_client::{sglang_proto as proto, sglang_scheduler::{SglangSchedulerClient, AbortOnDropStream}};
+use sgl_model_gateway::grpc_client::{sglang_proto as proto, sglang_scheduler::{SglangSchedulerClient, AbortOnDropStream}};
 
 use super::error::{SglErrorCode, set_error_message};
 use super::grpc_converter::{GrpcResponseConverterHandle, convert_proto_chunk_to_openai};

sgl-router/bindings/golang/src/tokenizer.rs

@@ -6,7 +6,7 @@ use std::ptr;
 use std::sync::Arc;
 use serde_json::Value;
 
-use sglang_router::tokenizer::{
+use sgl_model_gateway::tokenizer::{
     create_tokenizer_from_file,
     traits::Tokenizer as TokenizerTrait,
     chat_template::ChatTemplateParams,