Move lora request validation to tokenizer_manager from server (#18962)

Co-authored-by: Satyam Kumar <satyamk@linkedin.com>

test/registered/lora/test_embedding_lora_support.py

@@ -46,6 +46,24 @@ register_cuda_ci(
 class TestEmbeddingLoraSupport(unittest.TestCase):
     """Test LoRA support in embedding request structures."""
 
+    def test_engine_encode_validates_enable_lora(self):
+        """Test Engine.encode() validates enable_lora before processing lora_path."""
+        # Use a simple non-gated model for this validation test
+        with SRTRunner(
+            MODEL_PATH,
+            torch_dtype=torch.float16,
+            model_type="embedding",
+            port=DEFAULT_PORT_FOR_SRT_TEST_RUNNER,
+        ) as runner:
+            # Should raise ValueError because enable_lora was not set for the server
+            with self.assertRaises(ValueError) as context:
+                runner.engine.encode(prompt="Test", lora_path="fake-adapter")
+
+            error_msg = str(context.exception)
+            self.assertIn("not enabled", error_msg.lower())
+            self.assertIn("--enable-lora", error_msg)
+            self.assertIn("fake-adapter", error_msg)
+
     def test_embedding_lora_fields(self):
         """Test LoRA fields exist and work correctly across all embedding structures."""
         # EmbeddingReqInput: fields exist, normalization expands single to batch, indexing works

test/registered/lora/test_lora_openai_api.py

@@ -142,44 +142,6 @@ class TestResolveLoraPath(unittest.TestCase):
         self.assertEqual(result, "adapter-name")
 
 
-class TestValidateLoraEnabled(unittest.TestCase):
-    """Test _validate_lora_enabled method."""
-
-    def test_validation_passes_when_lora_enabled(self):
-        """Test validation passes when LoRA is enabled."""
-        tokenizer_manager = MockTokenizerManager(enable_lora=True)
-        serving = ConcreteServingBase(tokenizer_manager)
-
-        # Should not raise
-        try:
-            serving._validate_lora_enabled("sql-expert")
-        except ValueError:
-            self.fail("_validate_lora_enabled raised ValueError unexpectedly")
-
-    def test_validation_fails_when_lora_disabled(self):
-        """Test validation fails with helpful message when LoRA is disabled."""
-        tokenizer_manager = MockTokenizerManager(enable_lora=False)
-        serving = ConcreteServingBase(tokenizer_manager)
-
-        with self.assertRaises(ValueError) as context:
-            serving._validate_lora_enabled("sql-expert")
-
-        error_message = str(context.exception)
-        self.assertIn("sql-expert", error_message)
-        self.assertIn("--enable-lora", error_message)
-        self.assertIn("not enabled", error_message)
-
-    def test_validation_error_mentions_adapter_name(self):
-        """Test that error message includes the requested adapter name."""
-        tokenizer_manager = MockTokenizerManager(enable_lora=False)
-        serving = ConcreteServingBase(tokenizer_manager)
-
-        with self.assertRaises(ValueError) as context:
-            serving._validate_lora_enabled("my-custom-adapter")
-
-        self.assertIn("my-custom-adapter", str(context.exception))
-
-
 class TestIntegrationScenarios(unittest.TestCase):
     """Integration tests for common usage scenarios."""
 
@@ -196,9 +158,6 @@ class TestIntegrationScenarios(unittest.TestCase):
         lora_path = self.serving._resolve_lora_path(model, explicit_lora)
         self.assertEqual(lora_path, "sql-expert")
 
-        # Validation should pass
-        self.serving._validate_lora_enabled(lora_path)
-
     def test_backward_compatible_usage(self):
         """Test backward-compatible usage with explicit lora_path."""
         model = "meta-llama/Llama-3.1-8B"
@@ -207,9 +166,6 @@ class TestIntegrationScenarios(unittest.TestCase):
         lora_path = self.serving._resolve_lora_path(model, explicit_lora)
         self.assertEqual(lora_path, "sql-expert")
 
-        # Validation should pass
-        self.serving._validate_lora_enabled(lora_path)
-
     def test_base_model_usage(self):
         """Test using base model without any adapter."""
         model = "meta-llama/Llama-3.1-8B"
@@ -228,10 +184,6 @@ class TestIntegrationScenarios(unittest.TestCase):
         lora_path = self.serving._resolve_lora_path(model, explicit_lora)
         self.assertEqual(lora_path, explicit_lora)
 
-        # Validate first adapter in list
-        if isinstance(lora_path, list) and lora_path[0]:
-            self.serving._validate_lora_enabled(lora_path[0])
-
     def test_adapter_in_model_overrides_batch_list(self):
         """Test that adapter in model parameter overrides batch list."""
         model = "meta-llama/Llama-3.1-8B:preferred-adapter"
@@ -240,24 +192,6 @@ class TestIntegrationScenarios(unittest.TestCase):
         lora_path = self.serving._resolve_lora_path(model, explicit_lora)
         self.assertEqual(lora_path, "preferred-adapter")
 
-    def test_error_when_lora_not_enabled(self):
-        """Test comprehensive error flow when LoRA is not enabled."""
-        # Setup server without LoRA enabled
-        tokenizer_manager = MockTokenizerManager(enable_lora=False)
-        serving = ConcreteServingBase(tokenizer_manager)
-
-        # User tries to use adapter
-        model = "meta-llama/Llama-3.1-8B:sql-expert"
-        lora_path = serving._resolve_lora_path(model, None)
-
-        # Should get helpful error
-        with self.assertRaises(ValueError) as context:
-            serving._validate_lora_enabled(lora_path)
-
-        error = str(context.exception)
-        self.assertIn("--enable-lora", error)
-        self.assertIn("sql-expert", error)
-
 
 class TestEdgeCases(unittest.TestCase):
     """Test edge cases and error conditions."""
@@ -318,14 +252,6 @@ class TestEdgeCases(unittest.TestCase):
         result = self.serving._resolve_lora_path("model-name", "")
         self.assertEqual(result, "")
 
-    def test_validation_with_empty_adapter_name(self):
-        """Test validation with empty adapter name still raises error."""
-        tokenizer_manager = MockTokenizerManager(enable_lora=False)
-        serving = ConcreteServingBase(tokenizer_manager)
-
-        with self.assertRaises(ValueError):
-            serving._validate_lora_enabled("")
-
 
 if __name__ == "__main__":
     unittest.main()