[Bugfix][Frontend] Fix Responses namespace aliases in named tool calling (#59723)

Signed-off-by: Shen <312058264+YueshenZ@users.noreply.github.com>
Signed-off-by: sfeng33 <4florafeng@gmail.com>
Co-authored-by: sfeng33 <4florafeng@gmail.com>
This commit is contained in:
YueshenZ
2026-10-08 00:07:52 +00:00
committed by GitHub
co-authored by sfeng33
parent 38dc8ee500
commit ed825aafc0
4 changed files with 124 additions and 24 deletions
+2
View File
@@ -94,6 +94,8 @@ For best results, we recommend ensuring that the expected output format / schema
To use a named function, you need to define the functions in the `tools` parameter of the chat completion request, and
specify the `name` of one of the tools in the `tool_choice` parameter of the chat completion request.
In the Responses API, `tool_choice={"type": "function", "name": "..."}` can select a function inside a namespace by its full `namespace__function` name or by its local name. Names are matched literally first, so a plain function named `other__add` never stands in for `add`. A local name defined in more than one namespace must be selected by its full name.
## Required Function Calling
vLLM supports the `tool_choice='required'` option in the chat completion API. Similar to the named function calling, it also uses structured outputs, so this is enabled by default and will work with any supported model. However, support for alternative decoding backends are on the [roadmap](../usage/v1_guide.md#features) for the V1 engine.
+73 -1
View File
@@ -5,7 +5,11 @@ from copy import deepcopy
import pytest
import regex as re
from openai.types.responses import FunctionTool, ToolChoiceFunction, WebSearchTool
from openai.types.responses import (
FunctionTool,
ToolChoiceFunction,
WebSearchTool,
)
from pydantic import TypeAdapter
from vllm.entrypoints.openai.chat_completion.protocol import (
@@ -13,6 +17,7 @@ from vllm.entrypoints.openai.chat_completion.protocol import (
ChatCompletionNamedToolChoiceParam,
ChatCompletionToolsParam,
)
from vllm.entrypoints.openai.responses.protocol import ResponsesRequest
from vllm.exceptions import VLLMValidationError
from vllm.tool_parsers.streaming import extract_required_tool_call_streaming
from vllm.tool_parsers.utils import (
@@ -581,3 +586,70 @@ class TestForcedNamedToolChoiceEmptyParams:
choice = ToolChoiceFunction(type="function", name="ping")
schema = get_json_schema_from_tools(choice, [tool])
assert schema == {"type": "object", "properties": {}}
class TestForcedFunctionShortNameAlias:
"""Forced choices must use the selected function's parameter schema."""
PARAMS = {"type": "object", "properties": {"x": {"type": "integer"}}}
@pytest.mark.parametrize("plain_first", [True, False])
@pytest.mark.parametrize(
"namespace,function_name,choice_name",
[
("math", "add", "add"),
("math", "add", "math__add"),
("math", "vector__add", "vector__add"),
("math__vector", "vector__add", "vector__add"),
],
)
def test_namespace_schema_is_not_shadowed(
self, plain_first, namespace, function_name, choice_name
):
tools = [
{
"type": "function",
"name": "other__add",
"parameters": {
"type": "object",
"properties": {"y": {"type": "string"}},
},
},
{
"type": "namespace",
"name": namespace,
"description": "math tools",
"tools": [
{
"type": "function",
"name": function_name,
"parameters": self.PARAMS,
}
],
},
]
if not plain_first:
tools.reverse()
request = ResponsesRequest.model_validate(
{
"model": "test-model",
"input": "Add the numbers.",
"tools": tools,
"tool_choice": {"type": "function", "name": choice_name},
}
)
assert (
get_json_schema_from_tools(request.tool_choice, request.tools)
== self.PARAMS
)
def test_plain_function_double_underscore_name_has_no_phantom_alias(self):
tool = FunctionTool(type="function", name="math__add", parameters=self.PARAMS)
choice = ToolChoiceFunction(type="function", name="add")
with pytest.raises(ValueError, match="has not been passed in `tools`"):
get_json_schema_from_tools(choice, [tool])
def test_plain_function_full_name_still_resolves(self):
tool = FunctionTool(type="function", name="math__add", parameters=self.PARAMS)
choice = ToolChoiceFunction(type="function", name="math__add")
assert get_json_schema_from_tools(choice, [tool]) == self.PARAMS
+49 -21
View File
@@ -159,6 +159,51 @@ def _default_input_image_details(value: Any) -> Any:
return {**value, "content": new_content} if changed else value
def _tool_field(tool: Any, field: str) -> Any:
return tool.get(field) if isinstance(tool, dict) else getattr(tool, field, None)
def _resolve_named_tool_choice(tool_name: str, tools: list[Any]) -> str:
"""Resolve a named tool choice to the flat ``<namespace>__<name>`` form."""
from vllm.tool_parsers.utils import flat_namespace_tool_name
exact_names: set[str] = set()
local_names: dict[str, list[str]] = {}
for tool in tools:
if _tool_field(tool, "type") == "namespace":
namespace = _tool_field(tool, "name")
namespaced_tools = _tool_field(tool, "tools")
if not isinstance(namespaced_tools, list) or not isinstance(namespace, str):
return tool_name
for namespaced_tool in namespaced_tools:
local_name = _tool_field(namespaced_tool, "name")
if not isinstance(local_name, str):
continue
flat_name = flat_namespace_tool_name(namespace, local_name)
exact_names.add(flat_name)
local_names.setdefault(local_name, []).append(flat_name)
else:
name = _tool_field(tool, "name")
if isinstance(name, str):
exact_names.add(name)
if tool_name in exact_names:
return tool_name
candidates = local_names.get(tool_name, [])
if len(candidates) == 1:
return candidates[0]
if len(candidates) > 1:
raise VLLMValidationError(
f"Tool choice '{tool_name}' is ambiguous: it is defined in more "
f"than one namespace ({', '.join(candidates)}). Select it by its "
"full '<namespace>__<name>' name.",
parameter="tool_choice",
)
raise VLLMValidationError(
"Tool choice 'function' not found in 'tools' parameter.",
parameter="tool_choice",
)
class ResponsesRequest(OpenAIBaseModel):
# Ordered by official OpenAI API documentation
# https://platform.openai.com/docs/api-reference/responses/create
@@ -662,31 +707,14 @@ class ResponsesRequest(OpenAIBaseModel):
)
elif is_named_tool_choice and tools is not None:
tool_name = tool_choice.get("name")
tool_names = set()
for tool in tools:
if isinstance(tool, dict):
if tool.get("type") == "namespace":
namespace = tool.get("name")
namespaced_tools = tool.get("tools")
if not isinstance(namespaced_tools, list):
return data
for namespaced_tool in namespaced_tools:
namespaced_name = (
namespaced_tool.get("name")
if isinstance(namespaced_tool, dict)
else getattr(namespaced_tool, "name", None)
)
tool_names.add(namespaced_name)
tool_names.add(f"{namespace}__{namespaced_name}")
else:
tool_names.add(tool.get("name"))
else:
tool_names.add(getattr(tool, "name", None))
if not tool_name or tool_name not in tool_names:
if not tool_name:
raise VLLMValidationError(
"Tool choice 'function' not found in 'tools' parameter.",
parameter="tool_choice",
)
resolved = _resolve_named_tool_choice(tool_name, tools)
if resolved != tool_name:
data["tool_choice"] = {**tool_choice, "name": resolved}
return data
-2
View File
@@ -432,8 +432,6 @@ def get_json_schema_from_tools(
continue
for name, params in iter_response_function_tool_info(tool):
responses_tool_map[name] = params
if "__" in name:
responses_tool_map.setdefault(name.rsplit("__", 1)[1], params)
if tool_name not in responses_tool_map:
raise ValueError(f"Tool '{tool_name}' has not been passed in `tools`.")
return _params_or_empty_object(responses_tool_map[tool_name])