[Frontend] OpenAI Responses API supports Tool/Function calling

Signed-off-by: chaunceyjiang <chaunceyjiang@gmail.com>

Author: chaunceyjiang

tests/entrypoints/openai/serving_responses/conftest.py

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+import pytest
+import pytest_asyncio
+
+from tests.utils import RemoteOpenAIServer
+
+# Use a small reasoning model to test the responses API.
+MODEL_NAME = "Qwen/Qwen3-0.6B"
+
+
+@pytest.fixture(scope="module")
+def default_server_args():
+    return [
+        "--max-model-len",
+        "8192",
+        "--enforce-eager",  # For faster startup.
+        "--enable-auto-tool-choice",
+        "--structured-outputs-config.backend",
+        "xgrammar",
+        "--tool-call-parser",
+        "hermes",
+        "--reasoning-parser",
+        "qwen3",
+    ]
+
+
+@pytest.fixture(scope="module")
+def server_with_store(default_server_args):
+    with RemoteOpenAIServer(
+        MODEL_NAME,
+        default_server_args,
+        env_dict={"VLLM_ENABLE_RESPONSES_API_STORE": "1"},
+    ) as remote_server:
+        yield remote_server
+
+
+@pytest_asyncio.fixture
+async def client(server_with_store):
+    async with server_with_store.get_async_client() as async_client:
+        yield async_client

tests/v1/entrypoints/openai/responses/test_function_call.py renamed to tests/entrypoints/openai/serving_responses/test_function_call.py

@@ -6,7 +6,10 @@
 import openai  # use the official client for correctness check
 import pytest
 
+# Use a small reasoning model to test the responses API.
 MODEL_NAME = "Qwen/Qwen3-0.6B"
+
+
 tools = [
     {
         "type": "function",

tests/v1/entrypoints/openai/responses/conftest.py

@@ -15,13 +15,8 @@ def default_server_args():
         "--max-model-len",
         "8192",
         "--enforce-eager",  # For faster startup.
-        "--enable-auto-tool-choice",
-        "--structured-outputs-config.backend",
-        "xgrammar",
-        "--tool-call-parser",
-        "hermes",
         "--reasoning-parser",
-        "qwen3",
+        "deepseek_r1",
     ]
 
 

vllm/entrypoints/openai/protocol.py

@@ -16,7 +16,6 @@
 )
 from openai.types.chat.chat_completion_message import Annotation as OpenAIAnnotation
 from openai.types.responses import (
-    FunctionTool,
     ResponseCodeInterpreterCallCodeDeltaEvent,
     ResponseCodeInterpreterCallCodeDoneEvent,
     ResponseCodeInterpreterCallCompletedEvent,
@@ -37,7 +36,6 @@
     ResponseWebSearchCallCompletedEvent,
     ResponseWebSearchCallInProgressEvent,
     ResponseWebSearchCallSearchingEvent,
-    ToolChoiceFunction,
 )
 from openai.types.responses import (
     ResponseCompletedEvent as OpenAIResponseCompletedEvent,
@@ -73,6 +71,7 @@
 
 from vllm import envs
 from vllm.entrypoints.chat_utils import ChatCompletionMessageParam, make_tool_call_id
+from vllm.entrypoints.openai.utils import get_json_schema_from_tool
 from vllm.entrypoints.score_utils import ScoreContentPartParam, ScoreMultiModalParam
 from vllm.logger import init_logger
 from vllm.logprobs import Logprob
@@ -296,91 +295,6 @@ def get_logits_processors(
     return None
 
 
-def get_json_schema_from_tool(
-    tool_choice: str | ToolChoiceFunction | ChatCompletionNamedToolChoiceParam,
-    tools: list[FunctionTool | ChatCompletionToolsParam] | None,
-) -> str | dict | None:
-    if tool_choice in ("none", None) or tools is None:
-        return None
-    if (not isinstance(tool_choice, str)) and isinstance(
-        tool_choice, ToolChoiceFunction
-    ):
-        tool_name = tool_choice.name
-        tool_map = {tool.name: tool for tool in tools if isinstance(tool, FunctionTool)}
-        if tool_name not in tool_map:
-            raise ValueError(f"Tool '{tool_name}' has not been passed in `tools`.")
-        return tool_map[tool_name].parameters
-
-    if (not isinstance(tool_choice, str)) and isinstance(
-        tool_choice, ChatCompletionNamedToolChoiceParam
-    ):
-        tool_name = tool_choice.function.name
-        tool_map = {
-            tool.function.name: tool
-            for tool in tools
-            if isinstance(tool, ChatCompletionToolsParam)
-        }
-        if tool_name not in tool_map:
-            raise ValueError(f"Tool '{tool_name}' has not been passed in `tools`.")
-        return tool_map[tool_name].function.parameters
-
-    if tool_choice == "required":
-
-        def extract_tool_info(
-            tool: Tool | ChatCompletionToolsParam,
-        ) -> tuple[str, dict[str, Any] | None]:
-            if isinstance(tool, FunctionTool):
-                return tool.name, tool.parameters
-            elif isinstance(tool, ChatCompletionToolsParam):
-                return tool.function.name, tool.function.parameters
-            else:
-                raise TypeError(f"Unsupported tool type: {type(tool)}")
-
-        def get_tool_schema(tool: Tool | ChatCompletionToolsParam) -> dict:
-            name, params = extract_tool_info(tool)
-            params = params if params else {"type": "object", "properties": {}}
-            return {
-                "properties": {
-                    "name": {"type": "string", "enum": [name]},
-                    "parameters": params,
-                },
-                "required": ["name", "parameters"],
-            }
-
-        def get_tool_schema_defs(
-            tools: list[Tool | ChatCompletionToolsParam],
-        ) -> dict:
-            all_defs: dict[str, dict[str, Any]] = {}
-            for tool in tools:
-                _, params = extract_tool_info(tool)
-                if params is None:
-                    continue
-                defs = params.pop("$defs", {})
-                for def_name, def_schema in defs.items():
-                    if def_name in all_defs and all_defs[def_name] != def_schema:
-                        raise ValueError(
-                            f"Tool definition '{def_name}' has multiple schemas, "
-                            "which is not supported."
-                        )
-                    all_defs[def_name] = def_schema
-            return all_defs
-
-        json_schema = {
-            "type": "array",
-            "minItems": 1,
-            "items": {
-                "type": "object",
-                "anyOf": [get_tool_schema(tool) for tool in tools],
-            },
-        }
-        json_schema_defs = get_tool_schema_defs(tools)
-        if json_schema_defs:
-            json_schema["$defs"] = json_schema_defs
-        return json_schema
-
-    return None
-
-
 ResponseInputOutputItem: TypeAlias = (
     ResponseInputItemParam | ResponseReasoningItem | ResponseFunctionToolCall
 )

vllm/entrypoints/openai/utils.py

@@ -1,13 +1,22 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 import base64
-from typing import Literal
+from typing import Any, Literal
 
 import torch
+from openai.types.responses import (
+    FunctionTool,
+    ToolChoiceFunction,
+)
+from openai.types.responses.tool import Tool
 from typing_extensions import assert_never
 
 from vllm import PoolingRequestOutput
-from vllm.entrypoints.openai.protocol import EMBED_DTYPE_TO_TORCH_DTYPE
+from vllm.entrypoints.openai.protocol import (
+    EMBED_DTYPE_TO_TORCH_DTYPE,
+    ChatCompletionNamedToolChoiceParam,
+    ChatCompletionToolsParam,
+)
 
 
 def encoding_pooling_output(
@@ -31,3 +40,88 @@ def encoding_pooling_output(
         return base64.b64encode(embedding_bytes).decode("utf-8")
 
     assert_never(encoding_format)
+
+
+def get_json_schema_from_tool(
+    tool_choice: str | ToolChoiceFunction | ChatCompletionNamedToolChoiceParam,
+    tools: list[FunctionTool | ChatCompletionToolsParam] | None,
+) -> str | dict | None:
+    if tool_choice in ("none", None) or tools is None:
+        return None
+    if (not isinstance(tool_choice, str)) and isinstance(
+        tool_choice, ToolChoiceFunction
+    ):
+        tool_name = tool_choice.name
+        tool_map = {tool.name: tool for tool in tools if isinstance(tool, FunctionTool)}
+        if tool_name not in tool_map:
+            raise ValueError(f"Tool '{tool_name}' has not been passed in `tools`.")
+        return tool_map[tool_name].parameters
+
+    if (not isinstance(tool_choice, str)) and isinstance(
+        tool_choice, ChatCompletionNamedToolChoiceParam
+    ):
+        tool_name = tool_choice.function.name
+        tool_map = {
+            tool.function.name: tool
+            for tool in tools
+            if isinstance(tool, ChatCompletionToolsParam)
+        }
+        if tool_name not in tool_map:
+            raise ValueError(f"Tool '{tool_name}' has not been passed in `tools`.")
+        return tool_map[tool_name].function.parameters
+
+    if tool_choice == "required":
+
+        def extract_tool_info(
+            tool: Tool | ChatCompletionToolsParam,
+        ) -> tuple[str, dict[str, Any] | None]:
+            if isinstance(tool, FunctionTool):
+                return tool.name, tool.parameters
+            elif isinstance(tool, ChatCompletionToolsParam):
+                return tool.function.name, tool.function.parameters
+            else:
+                raise TypeError(f"Unsupported tool type: {type(tool)}")
+
+        def get_tool_schema(tool: Tool | ChatCompletionToolsParam) -> dict:
+            name, params = extract_tool_info(tool)
+            params = params if params else {"type": "object", "properties": {}}
+            return {
+                "properties": {
+                    "name": {"type": "string", "enum": [name]},
+                    "parameters": params,
+                },
+                "required": ["name", "parameters"],
+            }
+
+        def get_tool_schema_defs(
+            tools: list[Tool | ChatCompletionToolsParam],
+        ) -> dict:
+            all_defs: dict[str, dict[str, Any]] = {}
+            for tool in tools:
+                _, params = extract_tool_info(tool)
+                if params is None:
+                    continue
+                defs = params.pop("$defs", {})
+                for def_name, def_schema in defs.items():
+                    if def_name in all_defs and all_defs[def_name] != def_schema:
+                        raise ValueError(
+                            f"Tool definition '{def_name}' has multiple schemas, "
+                            "which is not supported."
+                        )
+                    all_defs[def_name] = def_schema
+            return all_defs
+
+        json_schema = {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "anyOf": [get_tool_schema(tool) for tool in tools],
+            },
+        }
+        json_schema_defs = get_tool_schema_defs(tools)
+        if json_schema_defs:
+            json_schema["$defs"] = json_schema_defs
+        return json_schema
+
+    return None