Remove deadcode that are not used and move unused API completeness methods

Author: CatherineSue

sgl-model-gateway/src/routers/grpc/common/stages/dispatch_metadata.rs

@@ -66,7 +66,6 @@ impl PipelineStage for DispatchMetadataStage {
             model,
             created,
             weight_version: Some(weight_version),
-            is_streaming: ctx.is_streaming(),
         });
 
         Ok(None)

sgl-model-gateway/src/routers/grpc/context.rs

@@ -153,8 +153,6 @@ pub(crate) struct DispatchMetadata {
     pub model: String,
     pub created: u64,
     pub weight_version: Option<String>,
-    #[allow(dead_code)]
-    pub is_streaming: bool,
 }
 
 /// Load guards for worker load tracking
@@ -369,19 +367,6 @@ impl RequestContext {
 }
 
 impl WorkerSelection {
-    #[allow(dead_code)]
-    pub fn is_dual(&self) -> bool {
-        matches!(self, Self::Dual { .. })
-    }
-
-    #[allow(dead_code)]
-    pub fn single(&self) -> Option<&Arc<dyn Worker>> {
-        match self {
-            Self::Single { worker } => Some(worker),
-            _ => None,
-        }
-    }
-
     /// Record circuit breaker outcome for all workers
     pub fn record_outcome(&self, success: bool) {
         match self {
@@ -400,8 +385,22 @@ impl WorkerSelection {
             decode.record_outcome(decode_success);
         }
     }
+}
+
+/// Accessor methods kept for API completeness.
+#[allow(dead_code)]
+impl WorkerSelection {
+    pub fn is_dual(&self) -> bool {
+        matches!(self, Self::Dual { .. })
+    }
+
+    pub fn single(&self) -> Option<&Arc<dyn Worker>> {
+        match self {
+            Self::Single { worker } => Some(worker),
+            _ => None,
+        }
+    }
 
-    #[allow(dead_code)]
     #[allow(clippy::type_complexity)]
     pub fn dual(&self) -> Option<(&Arc<dyn Worker>, &Arc<dyn Worker>)> {
         match self {
@@ -410,15 +409,13 @@ impl WorkerSelection {
         }
     }
 
-    #[allow(dead_code)]
     pub fn prefill_worker(&self) -> Option<&Arc<dyn Worker>> {
         match self {
             Self::Dual { prefill, .. } => Some(prefill),
             _ => None,
         }
     }
 
-    #[allow(dead_code)]
     pub fn decode_worker(&self) -> Option<&Arc<dyn Worker>> {
         match self {
             Self::Dual { decode, .. } => Some(decode),
@@ -428,11 +425,6 @@ impl WorkerSelection {
 }
 
 impl ClientSelection {
-    #[allow(dead_code)]
-    pub fn is_dual(&self) -> bool {
-        matches!(self, Self::Dual { .. })
-    }
-
     pub fn single(&self) -> Option<&GrpcClient> {
         match self {
             Self::Single { client } => Some(client),
@@ -447,46 +439,49 @@ impl ClientSelection {
         }
     }
 
-    #[allow(dead_code)]
-    pub fn dual(&self) -> Option<(&GrpcClient, &GrpcClient)> {
+    pub fn dual_mut(&mut self) -> Option<(&mut GrpcClient, &mut GrpcClient)> {
         match self {
             Self::Dual { prefill, decode } => Some((prefill, decode)),
             _ => None,
         }
     }
+}
 
-    pub fn dual_mut(&mut self) -> Option<(&mut GrpcClient, &mut GrpcClient)> {
+/// Accessor methods kept for API completeness.
+#[allow(dead_code)]
+impl ClientSelection {
+    pub fn is_dual(&self) -> bool {
+        matches!(self, Self::Dual { .. })
+    }
+
+    pub fn dual(&self) -> Option<(&GrpcClient, &GrpcClient)> {
         match self {
             Self::Dual { prefill, decode } => Some((prefill, decode)),
             _ => None,
         }
     }
 
-    #[allow(dead_code)]
     pub fn prefill_client(&self) -> Option<&GrpcClient> {
         match self {
             Self::Dual { prefill, .. } => Some(prefill),
             _ => None,
         }
     }
 
-    #[allow(dead_code)]
     pub fn prefill_client_mut(&mut self) -> Option<&mut GrpcClient> {
         match self {
             Self::Dual { prefill, .. } => Some(prefill),
             _ => None,
         }
     }
 
-    #[allow(dead_code)]
     pub fn decode_client(&self) -> Option<&GrpcClient> {
         match self {
             Self::Dual { decode, .. } => Some(decode),
             _ => None,
         }
     }
 
-    #[allow(dead_code)]
     pub fn decode_client_mut(&mut self) -> Option<&mut GrpcClient> {
         match self {
             Self::Dual { decode, .. } => Some(decode),

sgl-model-gateway/src/routers/grpc/harmony/types.rs

@@ -15,29 +15,9 @@ pub(crate) struct HarmonyMessage {
     pub content: String,
 }
 
-#[allow(dead_code)]
 impl HarmonyMessage {
-    pub fn new(role: impl Into<String>, content: impl Into<String>) -> Self {
-        Self {
-            role: role.into(),
-            content: content.into(),
-        }
-    }
-
-    pub fn user(content: impl Into<String>) -> Self {
-        Self::new("user", content)
-    }
-
-    pub fn assistant(content: impl Into<String>) -> Self {
-        Self::new("assistant", content)
-    }
-
-    pub fn system(content: impl Into<String>) -> Self {
-        Self::new("system", content)
-    }
-
     /// Convert from openai_harmony::chat::Message to our simplified HarmonyMessage
-    pub fn from_openai_harmony(msg: openai_harmony::chat::Message) -> Self {
+    pub(crate) fn from_openai_harmony(msg: openai_harmony::chat::Message) -> Self {
         // Extract role as string
         let role = match msg.author.role {
             openai_harmony::chat::Role::User => "user",
@@ -63,6 +43,29 @@ impl HarmonyMessage {
     }
 }
 
+/// Convenience constructors kept for API completeness.
+#[allow(dead_code)]
+impl HarmonyMessage {
+    pub fn new(role: impl Into<String>, content: impl Into<String>) -> Self {
+        Self {
+            role: role.into(),
+            content: content.into(),
+        }
+    }
+
+    pub fn user(content: impl Into<String>) -> Self {
+        Self::new("user", content)
+    }
+
+    pub fn assistant(content: impl Into<String>) -> Self {
+        Self::new("assistant", content)
+    }
+
+    pub fn system(content: impl Into<String>) -> Self {
+        Self::new("system", content)
+    }
+}
+
 /// Output from Harmony encoding process
 ///
 /// Contains the encoded input_ids, stop tokens, selection text for worker routing,
@@ -110,7 +113,6 @@ pub(crate) struct HarmonyChannelOutput {
 ///
 /// Represents incremental updates as tokens are parsed from the stream.
 #[derive(Debug, Clone)]
-#[allow(dead_code)]
 pub(crate) struct HarmonyChannelDelta {
     /// Delta for analysis/reasoning content
     pub analysis_delta: Option<String>,
@@ -122,6 +124,7 @@ pub(crate) struct HarmonyChannelDelta {
     pub final_delta: Option<String>,
 
     /// Whether this is the final delta
+    #[allow(dead_code)]
     pub is_final: bool,
 }
 

sgl-model-gateway/src/routers/grpc/regular/responses/context.rs

@@ -8,7 +8,6 @@ use std::{collections::HashMap, sync::Arc};
 use tokio::{sync::RwLock, task::JoinHandle};
 
 use crate::{
-    core::WorkerRegistry,
     data_connector::{ConversationItemStorage, ConversationStorage, ResponseStorage},
     grpc_client::SglangSchedulerClient,
     mcp::McpManager,
@@ -36,13 +35,9 @@ pub(crate) struct ResponsesContext {
     /// Chat pipeline for executing requests
     pub pipeline: Arc<RequestPipeline>,
 
-    /// Shared components (tokenizer, parsers, worker_registry)
+    /// Shared components (tokenizer, parsers)
     pub components: Arc<SharedComponents>,
 
-    /// Worker registry for validation
-    #[allow(dead_code)]
-    pub worker_registry: Arc<WorkerRegistry>,
-
     /// Response storage backend
     pub response_storage: Arc<dyn ResponseStorage>,
 
@@ -64,7 +59,6 @@ impl ResponsesContext {
     pub fn new(
         pipeline: Arc<RequestPipeline>,
         components: Arc<SharedComponents>,
-        worker_registry: Arc<WorkerRegistry>,
         response_storage: Arc<dyn ResponseStorage>,
         conversation_storage: Arc<dyn ConversationStorage>,
         conversation_item_storage: Arc<dyn ConversationItemStorage>,
@@ -73,7 +67,6 @@ impl ResponsesContext {
         Self {
             pipeline,
             components,
-            worker_registry,
             response_storage,
             conversation_storage,
             conversation_item_storage,

sgl-model-gateway/src/routers/grpc/router.rs

@@ -116,7 +116,6 @@ impl GrpcRouter {
             responses::ResponsesContext::new(
                 Arc::new(pipeline.clone()),
                 shared_components.clone(),
-                worker_registry.clone(),
                 ctx.response_storage.clone(),
                 ctx.conversation_storage.clone(),
                 ctx.conversation_item_storage.clone(),