[Bugfix] Add validation for tool requests when tool_parser is unavailable

When `tool_choice` is set to `"required"`, a named tool, or `"auto"`,
but the server was not started with `--tool-call-parser`, vLLM would
silently degrade instead of returning a clear error.

This PR adds validation to return an appropriate error message:
- For `tool_choice="auto"` without `--enable-auto-tool-choice`:
  requires both flags
- For `tool_choice="auto"` with `--enable-auto-tool-choice` but no parser:
  requires `--tool-call-parser`
- For `tool_choice="required"` or named tool:
  requires `--tool-call-parser`

Fixes #29432

Signed-off-by: majiayu000 <[email protected]>

Author: majiayu000

tests/entrypoints/openai/test_serving_chat.py

@@ -1372,3 +1372,95 @@ async def test_non_tool_reasoning_empty_content_list(self, serving_chat):
                 },
             ],
         )
+
+
+@pytest.mark.asyncio
+async def test_tool_choice_validation_without_parser():
+    """Test that tool_choice='required' or named tool without tool_parser
+    returns an appropriate error message."""
+    mock_engine = MagicMock(spec=AsyncLLM)
+    mock_engine.get_tokenizer.return_value = get_tokenizer(MODEL_NAME)
+    mock_engine.errored = False
+    mock_engine.model_config = MockModelConfig()
+    mock_engine.input_processor = MagicMock()
+    mock_engine.io_processor = MagicMock()
+
+    models = OpenAIServingModels(
+        engine_client=mock_engine,
+        base_model_paths=BASE_MODEL_PATHS,
+    )
+    # Create serving_chat without tool_parser (enable_auto_tools=False)
+    serving_chat = OpenAIServingChat(
+        mock_engine,
+        models,
+        response_role="assistant",
+        chat_template=CHAT_TEMPLATE,
+        chat_template_content_format="auto",
+        request_logger=None,
+        enable_auto_tools=False,  # No tool parser
+    )
+
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_weather",
+                "description": "Get the weather in a given location",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"location": {"type": "string"}},
+                    "required": ["location"],
+                },
+            },
+        }
+    ]
+
+    # Test tool_choice="required" without tool_parser
+    req_required = ChatCompletionRequest(
+        model=MODEL_NAME,
+        messages=[{"role": "user", "content": "What's the weather?"}],
+        tools=tools,
+        tool_choice="required",
+    )
+    response_required = await serving_chat.create_chat_completion(req_required)
+    assert hasattr(response_required, "body")
+    error_body = response_required.body.decode()
+    assert "tool_choice" in error_body
+    assert "--tool-call-parser" in error_body
+
+    # Test named tool_choice without tool_parser
+    req_named = ChatCompletionRequest(
+        model=MODEL_NAME,
+        messages=[{"role": "user", "content": "What's the weather?"}],
+        tools=tools,
+        tool_choice={"type": "function", "function": {"name": "get_weather"}},
+    )
+    response_named = await serving_chat.create_chat_completion(req_named)
+    assert hasattr(response_named, "body")
+    error_body = response_named.body.decode()
+    assert "tool_choice" in error_body
+    assert "--tool-call-parser" in error_body
+
+    # Test tool_choice="auto" with enable_auto_tools=True but no tool_parser
+    # This is a regression test: enable_auto_tools is set but tool_parser is None
+    serving_chat_auto_enabled = OpenAIServingChat(
+        mock_engine,
+        models,
+        response_role="assistant",
+        chat_template=CHAT_TEMPLATE,
+        chat_template_content_format="auto",
+        request_logger=None,
+        enable_auto_tools=True,  # Enabled but no tool_parser configured
+    )
+
+    req_auto = ChatCompletionRequest(
+        model=MODEL_NAME,
+        messages=[{"role": "user", "content": "What's the weather?"}],
+        tools=tools,
+        tool_choice="auto",
+    )
+    response_auto = await serving_chat_auto_enabled.create_chat_completion(req_auto)
+    assert hasattr(response_auto, "body")
+    error_body = response_auto.body.decode()
+    assert "auto" in error_body
+    assert "--tool-call-parser" in error_body

vllm/entrypoints/openai/serving_chat.py

@@ -204,18 +204,37 @@ async def create_chat_completion(
                 truncate_tool_call_ids(request)
                 validate_request_params(request)
 
-            if (
-                request.tool_choice == "auto"
-                and not (self.enable_auto_tools and tool_parser is not None)
+            # Check if tool parsing is unavailable
+            tool_parsing_unavailable = (
+                tool_parser is None
                 and not isinstance(tokenizer, MistralTokenizer)
                 and not self.use_harmony
+            )
+
+            # Validate tool_choice when tool parsing is required but unavailable
+            if tool_parsing_unavailable and request.tool_choice not in (
+                None,
+                "none",
             ):
-                # for hf tokenizers, "auto" tools requires
-                # --enable-auto-tool-choice and --tool-call-parser
-                return self.create_error_response(
-                    '"auto" tool choice requires '
-                    "--enable-auto-tool-choice and --tool-call-parser to be set"
-                )
+                if request.tool_choice == "auto":
+                    if not self.enable_auto_tools:
+                        # for hf tokenizers, "auto" tools requires
+                        # --enable-auto-tool-choice and --tool-call-parser
+                        return self.create_error_response(
+                            '"auto" tool choice requires '
+                            "--enable-auto-tool-choice and "
+                            "--tool-call-parser to be set"
+                        )
+                    # enable_auto_tools is set but tool_parser is None
+                    return self.create_error_response(
+                        '"auto" tool choice requires --tool-call-parser to be set'
+                    )
+                else:
+                    # "required" or named tool requires tool parser
+                    return self.create_error_response(
+                        f'tool_choice="{request.tool_choice}" requires '
+                        "--tool-call-parser to be set"
+                    )
 
             if request.tools is None or (
                 request.tool_choice == "none"