[model-gateway] clean up router manager function order

sgl-router/src/routers/router_manager.rs

@@ -423,59 +423,59 @@ impl RouterTrait for RouterManager {
         }
     }
 
-    async fn delete_response(&self, _headers: Option<&HeaderMap>, _response_id: &str) -> Response {
-        (
-            StatusCode::NOT_IMPLEMENTED,
-            "responses api not yet implemented in inference gateway mode",
-        )
-            .into_response()
-    }
-
-    async fn list_response_input_items(
+    async fn get_response(
         &self,
         headers: Option<&HeaderMap>,
         response_id: &str,
+        params: &ResponsesGetParams,
     ) -> Response {
-        // Delegate to the default router (typically http-regular)
-        // Response storage is shared across all routers via AppContext
         let router = self.select_router_for_request(headers, None);
         if let Some(router) = router {
-            router.list_response_input_items(headers, response_id).await
+            router.get_response(headers, response_id, params).await
         } else {
             (
                 StatusCode::NOT_FOUND,
-                "No router available to list response input items",
+                format!("No router available to get response '{}'", response_id),
             )
                 .into_response()
         }
     }
 
-    async fn get_response(
-        &self,
-        headers: Option<&HeaderMap>,
-        response_id: &str,
-        params: &ResponsesGetParams,
-    ) -> Response {
+    async fn cancel_response(&self, headers: Option<&HeaderMap>, response_id: &str) -> Response {
         let router = self.select_router_for_request(headers, None);
         if let Some(router) = router {
-            router.get_response(headers, response_id, params).await
+            router.cancel_response(headers, response_id).await
         } else {
             (
                 StatusCode::NOT_FOUND,
-                format!("No router available to get response '{}'", response_id),
+                format!("No router available to cancel response '{}'", response_id),
             )
                 .into_response()
         }
     }
 
-    async fn cancel_response(&self, headers: Option<&HeaderMap>, response_id: &str) -> Response {
+    async fn delete_response(&self, _headers: Option<&HeaderMap>, _response_id: &str) -> Response {
+        (
+            StatusCode::NOT_IMPLEMENTED,
+            "responses api not yet implemented in inference gateway mode",
+        )
+            .into_response()
+    }
+
+    async fn list_response_input_items(
+        &self,
+        headers: Option<&HeaderMap>,
+        response_id: &str,
+    ) -> Response {
+        // Delegate to the default router (typically http-regular)
+        // Response storage is shared across all routers via AppContext
         let router = self.select_router_for_request(headers, None);
         if let Some(router) = router {
-            router.cancel_response(headers, response_id).await
+            router.list_response_input_items(headers, response_id).await
         } else {
             (
                 StatusCode::NOT_FOUND,
-                format!("No router available to cancel response '{}'", response_id),
+                "No router available to list response input items",
             )
                 .into_response()
         }
@@ -500,48 +500,44 @@ impl RouterTrait for RouterManager {
         }
     }
 
-    async fn route_rerank(
+    async fn route_classify(
         &self,
         headers: Option<&HeaderMap>,
-        body: &RerankRequest,
+        body: &ClassifyRequest,
         model_id: Option<&str>,
     ) -> Response {
         let router = self.select_router_for_request(headers, model_id);
 
         if let Some(router) = router {
-            router.route_rerank(headers, body, model_id).await
+            router.route_classify(headers, body, model_id).await
         } else {
             (
                 StatusCode::NOT_FOUND,
-                "No router available for rerank request",
+                format!("Model '{}' not found or no router available", body.model),
             )
                 .into_response()
         }
     }
 
-    async fn route_classify(
+    async fn route_rerank(
         &self,
         headers: Option<&HeaderMap>,
-        body: &ClassifyRequest,
+        body: &RerankRequest,
         model_id: Option<&str>,
     ) -> Response {
         let router = self.select_router_for_request(headers, model_id);
 
         if let Some(router) = router {
-            router.route_classify(headers, body, model_id).await
+            router.route_rerank(headers, body, model_id).await
         } else {
             (
                 StatusCode::NOT_FOUND,
-                format!("Model '{}' not found or no router available", body.model),
+                "No router available for rerank request",
             )
                 .into_response()
         }
     }
 
-    fn router_type(&self) -> &'static str {
-        "manager"
-    }
-
     // Conversations API delegates
     async fn create_conversation(&self, headers: Option<&HeaderMap>, body: &Value) -> Response {
         let router = self.select_router_for_request(headers, None);
@@ -713,6 +709,10 @@ impl RouterTrait for RouterManager {
                 .into_response()
         }
     }
+
+    fn router_type(&self) -> &'static str {
+        "manager"
+    }
 }
 
 impl std::fmt::Debug for RouterManager {