style: fix pre-commit lint — ruff formatting and mypy type errors

- ruff: reformat long lines in tests and serving.py
- mypy: annotate base_tag as dict[str, Any] in gptoss_reasoning_parser
  to allow nested dict indexing through copy.deepcopy result
- mypy: suppress arg-type on list(name) in abs_reasoning_parsers where
  TypeIs narrowing is not respected under --python-version 3.10

Signed-off-by: Will Deines <will@garr.io>

Author: garrio-1

tests/entrypoints/openai/parser/test_harmony_utils.py

@@ -944,9 +944,7 @@ def test_none_instructions_creates_section(self):
         assert '{"type":"object"}' in result
 
     def test_custom_format_name(self):
-        result = inject_response_formats(
-            None, {"type": "object"}, format_name="order"
-        )
+        result = inject_response_formats(None, {"type": "object"}, format_name="order")
         assert "## order" in result
 
     def test_compact_json_no_spaces(self):
@@ -955,15 +953,8 @@ def test_compact_json_no_spaces(self):
             "properties": {"name": {"type": "string"}},
         }
         result = inject_response_formats(None, schema)
-        assert (
-            '{"type":"object","properties":{"name":{"type":"string"}}}'
-            in result
-        )
+        assert '{"type":"object","properties":{"name":{"type":"string"}}}' in result
 
     def test_section_separated_by_blank_lines(self):
-        result = inject_response_formats(
-            "Instructions here.", {"type": "object"}
-        )
-        assert (
-            "\n\n# Response Formats\n\n## structured_output\n\n" in result
-        )
+        result = inject_response_formats("Instructions here.", {"type": "object"})
+        assert "\n\n# Response Formats\n\n## structured_output\n\n" in result

tests/entrypoints/openai/responses/test_structured_output.py

@@ -141,9 +141,7 @@ def test_choice(self):
 
     def test_structural_tag_only_returns_none(self):
         """structural_tag is not a content constraint -- should return None."""
-        params = StructuredOutputsParams(
-            structural_tag='{"type": "structural_tag"}'
-        )
+        params = StructuredOutputsParams(structural_tag='{"type": "structural_tag"}')
         result = _constraint_to_content_format(params)
 
         assert result is None

tests/reasoning/test_gptoss_reasoning_parser.py

@@ -15,7 +15,6 @@
     from_function_tool_to_tag,
     no_func_reasoning_tag,
     tag_with_builtin_funcs,
-    tag_with_function_tools,
 )
 
 REASONING_MODEL_NAME = "openai/gpt-oss-120b"
@@ -410,10 +409,7 @@ def test_prepare_structured_tag_with_json_schema(self, reasoning_parser):
         assert len(parsed["format"]["tags"]) == 2
 
         # Verify analysis tag is unchanged
-        assert (
-            parsed["format"]["tags"][0]["begin"]
-            == "<|channel|>analysis<|message|>"
-        )
+        assert parsed["format"]["tags"][0]["begin"] == "<|channel|>analysis<|message|>"
         assert parsed["format"]["tags"][0]["content"]["type"] == "any_text"
 
         # Verify final channel tag has the json_schema content constraint
@@ -531,21 +527,13 @@ def test_tool_choice_required_with_function_tools(self, reasoning_parser):
 
         tag_begins = [t["begin"] for t in parsed["format"]["tags"]]
         # Function tool tags present
-        assert (
-            "<|channel|>commentary to=functions.get_weather<|message|>"
-            in tag_begins
-        )
-        assert (
-            "<|channel|>analysis to=functions.get_weather<|message|>"
-            in tag_begins
-        )
+        assert "<|channel|>commentary to=functions.get_weather<|message|>" in tag_begins
+        assert "<|channel|>analysis to=functions.get_weather<|message|>" in tag_begins
         # No final
         assert not any("final" in b for b in tag_begins)
         assert "<|channel|>final" not in parsed["format"]["triggers"]
 
-    def test_tool_choice_required_ignores_final_content_format(
-        self, reasoning_parser
-    ):
+    def test_tool_choice_required_ignores_final_content_format(self, reasoning_parser):
         """Final is blocked even when final_content_format is provided."""
         content_fmt = {
             "type": "json_schema",
@@ -564,9 +552,7 @@ def test_tool_choice_required_ignores_final_content_format(
         tag_begins = [t["begin"] for t in parsed["format"]["tags"]]
         assert not any("final" in b for b in tag_begins)
 
-    def test_tool_choice_auto_with_tools_and_content_format(
-        self, reasoning_parser
-    ):
+    def test_tool_choice_auto_with_tools_and_content_format(self, reasoning_parser):
         """Tool tags + final with content constraint for auto."""
         schema = {"type": "object", "properties": {"x": {"type": "integer"}}}
         content_fmt = {"type": "json_schema", "json_schema": schema}
@@ -583,10 +569,7 @@ def test_tool_choice_auto_with_tools_and_content_format(
 
         tag_begins = [t["begin"] for t in parsed["format"]["tags"]]
         # Function tool tags
-        assert (
-            "<|channel|>commentary to=functions.compute<|message|>"
-            in tag_begins
-        )
+        assert "<|channel|>commentary to=functions.compute<|message|>" in tag_begins
         # Final tag with content constraint
         assert "<|channel|>final<|message|>" in tag_begins
         assert "<|channel|>final" in parsed["format"]["triggers"]
@@ -598,9 +581,7 @@ def test_tool_choice_auto_with_tools_and_content_format(
         )
         assert final_tag["content"] == content_fmt
 
-    def test_tool_choice_auto_with_tools_final_is_any_text(
-        self, reasoning_parser
-    ):
+    def test_tool_choice_auto_with_tools_final_is_any_text(self, reasoning_parser):
         """auto + function tools but no content format -> final allows free text."""
         fn_tools = [{"name": "get_weather", "parameters": {"type": "object"}}]
         result = reasoning_parser.prepare_structured_tag(
@@ -655,14 +636,8 @@ def test_mixed_builtin_and_function_tools(
         assert "<|channel|>commentary to=browser" in tag_begins
         assert "<|channel|>analysis to=browser" in tag_begins
         # Function tool tags
-        assert (
-            "<|channel|>commentary to=functions.get_weather<|message|>"
-            in tag_begins
-        )
-        assert (
-            "<|channel|>analysis to=functions.get_weather<|message|>"
-            in tag_begins
-        )
+        assert "<|channel|>commentary to=functions.get_weather<|message|>" in tag_begins
+        assert "<|channel|>analysis to=functions.get_weather<|message|>" in tag_begins
         # Final tag (auto + function tools)
         assert "<|channel|>final<|message|>" in tag_begins
         # General commentary trigger covers both builtin and function
@@ -684,14 +659,8 @@ def test_named_tool_choice(self, reasoning_parser):
 
         tag_begins = [t["begin"] for t in parsed["format"]["tags"]]
         # Only get_weather tags, not get_stock
-        assert (
-            "<|channel|>commentary to=functions.get_weather<|message|>"
-            in tag_begins
-        )
-        assert (
-            "<|channel|>analysis to=functions.get_weather<|message|>"
-            in tag_begins
-        )
+        assert "<|channel|>commentary to=functions.get_weather<|message|>" in tag_begins
+        assert "<|channel|>analysis to=functions.get_weather<|message|>" in tag_begins
         assert not any("get_stock" in b for b in tag_begins)
         # No final (named tool choice blocks final)
         assert not any("final" in b for b in tag_begins)

vllm/entrypoints/openai/responses/serving.py

@@ -168,9 +168,7 @@ def _constraint_to_content_format(
     if params.choice is not None:
         return {
             "type": "or",
-            "elements": [
-                {"type": "const_string", "value": c} for c in params.choice
-            ],
+            "elements": [{"type": "const_string", "value": c} for c in params.choice],
         }
     return None
 
@@ -526,11 +524,7 @@ async def create_responses(
                 ft = [
                     {
                         "name": t.name,
-                        **(
-                            {"parameters": t.parameters}
-                            if t.parameters
-                            else {}
-                        ),
+                        **({"parameters": t.parameters} if t.parameters else {}),
                     }
                     for t in request.tools
                     if getattr(t, "type", None) == "function"
@@ -561,18 +555,14 @@ async def create_responses(
                         # Content constraint present (json, regex,
                         # grammar, choice, json_object). Embed it in the
                         # final channel tag within the structural tag.
-                        content_fmt = _constraint_to_content_format(
-                            struct_out
-                        )
+                        content_fmt = _constraint_to_content_format(struct_out)
                         if content_fmt is not None:
-                            structural_tag = (
-                                reasoning_parser.prepare_structured_tag(
-                                    None,
-                                    self.tool_server,
-                                    final_content_format=content_fmt,
-                                    tool_choice=request.tool_choice,
-                                    function_tools=function_tools_for_parser,
-                                )
+                            structural_tag = reasoning_parser.prepare_structured_tag(
+                                None,
+                                self.tool_server,
+                                final_content_format=content_fmt,
+                                tool_choice=request.tool_choice,
+                                function_tools=function_tools_for_parser,
                             )
                             if structural_tag is not None:
                                 # Clear content constraints, set
@@ -597,10 +587,8 @@ async def create_responses(
                         function_tools=function_tools_for_parser,
                     )
                     if tag is not None:
-                        sampling_params.structured_outputs = (
-                            StructuredOutputsParams(
-                                structural_tag=tag  # type: ignore[call-arg]
-                            )
+                        sampling_params.structured_outputs = StructuredOutputsParams(
+                            structural_tag=tag  # type: ignore[call-arg]
                         )
             generator = self._generate_with_builtin_tools(
                 request_id=request.request_id,
@@ -1256,9 +1244,7 @@ def _construct_input_messages_with_harmony(
             # structural tag grammar already blocks tool channels, but
             # omitting tools from the system/developer messages
             # prevents the model from even reasoning about calling them.
-            tools_visible = (
-                with_custom_tools and request.tool_choice != "none"
-            )
+            tools_visible = with_custom_tools and request.tool_choice != "none"
 
             sys_msg = self._construct_harmony_system_input_message(
                 request, tools_visible, tool_types
@@ -1269,9 +1255,7 @@ def _construct_input_messages_with_harmony(
             # Per Harmony cookbook: developer message holds instructions,
             # function tools, AND response format schemas.
             response_format_schema = _extract_response_format_schema(request)
-            needs_dev_msg = (
-                tools_visible or response_format_schema is not None
-            )
+            needs_dev_msg = tools_visible or response_format_schema is not None
 
             if needs_dev_msg:
                 dev_instructions = request.instructions

vllm/reasoning/abs_reasoning_parsers.py

@@ -312,7 +312,8 @@ def _decorator(obj: type[ReasoningParser]) -> type[ReasoningParser]:
             if isinstance(name, str):
                 names = [name]
             elif is_list_of(name, str):
-                names = name
+                assert name is not None
+                names = list(name)
             else:
                 names = [class_name]
 

vllm/reasoning/gptoss_reasoning_parser.py

@@ -3,7 +3,7 @@
 import copy
 import json
 from collections.abc import Sequence
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from transformers import PreTrainedTokenizerBase
 
@@ -81,17 +81,13 @@ def from_function_tool_to_tag(name: str, parameters: dict | None) -> list[dict]:
     ]
 
 
-def tag_with_function_tools(
-    base_tag: dict, function_tools: list[dict]
-) -> dict:
+def tag_with_function_tools(base_tag: dict, function_tools: list[dict]) -> dict:
     new_tag = copy.deepcopy(base_tag)
 
     # Add commentary trigger for function tools if not already covered
     # by the general commentary trigger (added by builtin tools).
     if "<|channel|>commentary to=" not in new_tag["format"]["triggers"]:
-        new_tag["format"]["triggers"].append(
-            "<|channel|>commentary to=functions."
-        )
+        new_tag["format"]["triggers"].append("<|channel|>commentary to=functions.")
 
     for tool in function_tools:
         new_tag["format"]["tags"].extend(
@@ -207,7 +203,7 @@ def prepare_structured_tag(
             # There is potential risk for appending the tag to the original tag
             return original_tag
 
-        base_tag = copy.deepcopy(no_func_reasoning_tag)
+        base_tag: dict[str, Any] = copy.deepcopy(no_func_reasoning_tag)
 
         # Add builtin tool tags (unless tool_choice is "none")
         if tool_choice != "none" and tool_server is not None:
@@ -236,9 +232,7 @@ def prepare_structured_tag(
                     t for t in function_tools if t["name"] == named
                 ]
             if effective_function_tools:
-                base_tag = tag_with_function_tools(
-                    base_tag, effective_function_tools
-                )
+                base_tag = tag_with_function_tools(base_tag, effective_function_tools)
 
         # Add final channel tag unless tool_choice blocks it
         if tool_choice != "required" and not isinstance(tool_choice, dict):
@@ -249,11 +243,13 @@ def prepare_structured_tag(
                     if final_content_format
                     else {"type": "any_text"}
                 )
-                base_tag["format"]["tags"].append({
-                    "begin": "<|channel|>final<|message|>",
-                    "content": final_content,
-                    "end": "<|end|>",
-                })
+                base_tag["format"]["tags"].append(
+                    {
+                        "begin": "<|channel|>final<|message|>",
+                        "content": final_content,
+                        "end": "<|end|>",
+                    }
+                )
                 base_tag["format"]["triggers"].append("<|channel|>final")
 
         # For tool_choice=required or named tool, force at least one triggered
@@ -267,7 +263,8 @@ def prepare_structured_tag(
             # satisfying at_least_one with a pure reasoning channel instead of
             # an actual tool call.
             base_tag["format"]["tags"] = [
-                t for t in base_tag["format"]["tags"]
+                t
+                for t in base_tag["format"]["tags"]
                 if t.get("begin") != "<|channel|>analysis<|message|>"
             ]
             base_tag["format"]["at_least_one"] = True