From cc67c0e0e219d6dc1f199e8bebaf1cb871f50a54 Mon Sep 17 00:00:00 2001 From: umut-polat <52835619+umut-polat@users.noreply.github.com> Date: Sun, 1 Mar 2026 16:16:16 +0000 Subject: [PATCH] use VLLMValidationError consistently in SamplingParams._verify_args some parameter checks in _verify_args raised plain ValueError or TypeError while others already used VLLMValidationError. the custom exception carries parameter name and value which the api layer uses to build structured error responses for clients. migrated all remaining ValueError/TypeError raises in _verify_args to VLLMValidationError with appropriate parameter and value kwargs. no changes to error message text or validation logic. Signed-off-by: Umut Polat <52835619+umut-polat@users.noreply.github.com> Signed-off-by: umut-polat <52835619+umut-polat@users.noreply.github.com> --- vllm/sampling_params.py | 80 +++++++++++++++++++++++++++++------------ 1 file changed, 58 insertions(+), 22 deletions(-) diff --git a/vllm/sampling_params.py b/vllm/sampling_params.py index f7a2e8b3f903..c2b3b20649ba 100644 --- a/vllm/sampling_params.py +++ b/vllm/sampling_params.py @@ -418,21 +418,35 @@ def __post_init__(self) -> None: def _verify_args(self) -> None: if not isinstance(self.n, int): - raise ValueError(f"n must be an int, but is of type {type(self.n)}") + raise VLLMValidationError( + f"n must be an int, but is of type {type(self.n)}", + parameter="n", + value=self.n, + ) if self.n < 1: - raise ValueError(f"n must be at least 1, got {self.n}.") + raise VLLMValidationError( + f"n must be at least 1, got {self.n}.", + parameter="n", + value=self.n, + ) if not -2.0 <= self.presence_penalty <= 2.0: - raise ValueError( - f"presence_penalty must be in [-2, 2], got {self.presence_penalty}." + raise VLLMValidationError( + f"presence_penalty must be in [-2, 2], got {self.presence_penalty}.", + parameter="presence_penalty", + value=self.presence_penalty, ) if not -2.0 <= self.frequency_penalty <= 2.0: - raise ValueError( - f"frequency_penalty must be in [-2, 2], got {self.frequency_penalty}." + raise VLLMValidationError( + f"frequency_penalty must be in [-2, 2], got {self.frequency_penalty}.", + parameter="frequency_penalty", + value=self.frequency_penalty, ) if self.repetition_penalty <= 0.0: - raise ValueError( + raise VLLMValidationError( "repetition_penalty must be greater than zero, got " - f"{self.repetition_penalty}." + f"{self.repetition_penalty}.", + parameter="repetition_penalty", + value=self.repetition_penalty, ) if self.temperature < 0.0: raise VLLMValidationError( @@ -448,15 +462,23 @@ def _verify_args(self) -> None: ) # quietly accept -1 as disabled, but prefer 0 if self.top_k < -1: - raise ValueError( - f"top_k must be 0 (disable), or at least 1, got {self.top_k}." + raise VLLMValidationError( + f"top_k must be 0 (disable), or at least 1, got {self.top_k}.", + parameter="top_k", + value=self.top_k, ) if not isinstance(self.top_k, int): - raise TypeError( - f"top_k must be an integer, got {type(self.top_k).__name__}" + raise VLLMValidationError( + f"top_k must be an integer, got {type(self.top_k).__name__}", + parameter="top_k", + value=self.top_k, ) if not 0.0 <= self.min_p <= 1.0: - raise ValueError(f"min_p must be in [0, 1], got {self.min_p}.") + raise VLLMValidationError( + f"min_p must be in [0, 1], got {self.min_p}.", + parameter="min_p", + value=self.min_p, + ) if self.max_tokens is not None and self.max_tokens < 1: raise VLLMValidationError( f"max_tokens must be at least 1, got {self.max_tokens}.", @@ -464,13 +486,18 @@ def _verify_args(self) -> None: value=self.max_tokens, ) if self.min_tokens < 0: - raise ValueError( - f"min_tokens must be greater than or equal to 0, got {self.min_tokens}." + raise VLLMValidationError( + "min_tokens must be greater than or equal to 0, " + f"got {self.min_tokens}.", + parameter="min_tokens", + value=self.min_tokens, ) if self.max_tokens is not None and self.min_tokens > self.max_tokens: - raise ValueError( + raise VLLMValidationError( f"min_tokens must be less than or equal to " - f"max_tokens={self.max_tokens}, got {self.min_tokens}." + f"max_tokens={self.max_tokens}, got {self.min_tokens}.", + parameter="min_tokens", + value=self.min_tokens, ) if self.logprobs is not None and self.logprobs != -1 and self.logprobs < 0: raise VLLMValidationError( @@ -491,16 +518,25 @@ def _verify_args(self) -> None: ) assert isinstance(self.stop_token_ids, list) if not all(isinstance(st_id, int) for st_id in self.stop_token_ids): - raise ValueError( - f"stop_token_ids must contain only integers, got {self.stop_token_ids}." + raise VLLMValidationError( + "stop_token_ids must contain only integers, " + f"got {self.stop_token_ids}.", + parameter="stop_token_ids", + value=self.stop_token_ids, ) assert isinstance(self.stop, list) if any(not stop_str for stop_str in self.stop): - raise ValueError("stop cannot contain an empty string.") + raise VLLMValidationError( + "stop cannot contain an empty string.", + parameter="stop", + value=self.stop, + ) if self.stop and not self.detokenize: - raise ValueError( + raise VLLMValidationError( "stop strings are only supported when detokenize is True. " - "Set detokenize=True to use stop." + "Set detokenize=True to use stop.", + parameter="stop", + value=self.stop, ) def _verify_greedy_sampling(self) -> None: