[Refactor] Deprecate ResponsesParser wrapper, inline parsing into ParsableContext (#45431)

Signed-off-by: sfeng33 <4florafeng@gmail.com>
This commit is contained in:
Flora Feng
2026-06-12 16:15:41 -04:00
committed by GitHub
parent aab639c705
commit 6e4a547176
5 changed files with 169 additions and 308 deletions
+93 -25
View File
@@ -10,9 +10,13 @@ from contextlib import AsyncExitStack
from dataclasses import replace
from typing import TYPE_CHECKING, Any, Final, Union
from openai.types.responses import ResponseFunctionToolCall, ResponseOutputItem
from openai.types.responses.response_function_tool_call_output_item import (
ResponseFunctionToolCallOutputItem,
)
from openai.types.responses.response_output_item import McpCall
from openai.types.responses.response_output_message import ResponseOutputMessage
from openai.types.responses.response_output_text import ResponseOutputText
from openai.types.responses.tool import Mcp
from openai_harmony import Author, Message, Role, StreamState, TextContent
@@ -30,15 +34,15 @@ from vllm.entrypoints.openai.parser.harmony_utils import (
get_streamable_parser_for_assistant,
render_for_completion,
)
from vllm.entrypoints.openai.parser.responses_parser import (
get_responses_parser_for_simple_context,
)
from vllm.entrypoints.openai.responses.protocol import (
ResponseInputOutputItem,
ResponseRawMessageAndToken,
ResponsesRequest,
)
from vllm.entrypoints.openai.responses.utils import construct_tool_dicts
from vllm.entrypoints.openai.responses.utils import (
build_response_output_items,
construct_tool_dicts,
)
from vllm.entrypoints.serve.utils.constants import MCP_PREFIX
from vllm.outputs import RequestOutput
from vllm.parser.abstract_parser import Parser
@@ -286,16 +290,24 @@ class ParsableContext(ConversationContext):
# not implemented yet for ParsableContext
self.all_turn_metrics: list[TurnMetrics] = []
self.parser = get_responses_parser_for_simple_context(
tokenizer=tokenizer,
parser_cls=parser_cls,
response_messages=response_messages,
request=request,
chat_template=chat_template,
chat_template_content_format=chat_template_content_format,
enable_auto_tools=enable_auto_tools,
tool_call_id_type=tool_call_id_type,
)
self.response_messages: list[ResponseInputOutputItem] = response_messages
self.num_init_messages = len(response_messages)
self.finish_reason: str | None = None
self.enable_auto_tools = enable_auto_tools
self.tool_call_id_type = tool_call_id_type
self.parser_instance: Parser | None = None
if parser_cls is not None:
chat_template_kwargs = request.build_chat_params(
default_template=chat_template,
default_template_content_format=chat_template_content_format,
).chat_template_kwargs
self.parser_instance = parser_cls(
tokenizer,
tools=request.tools,
chat_template_kwargs=chat_template_kwargs,
)
self.parser_cls = parser_cls
self.request = request
@@ -318,11 +330,44 @@ class ParsableContext(ConversationContext):
self.num_output_tokens += len(output.outputs[0].token_ids or [])
if output.kv_transfer_params is not None:
self.kv_transfer_params = output.kv_transfer_params
self.parser.process(output.outputs[0])
output_token_ids = output.outputs[0].token_ids or []
self._accumulated_token_ids.extend(output_token_ids)
# only store if enable_response_messages is True, save memory
completion = output.outputs[0]
self.finish_reason = completion.finish_reason
if self.parser_instance is not None:
reasoning, content, tool_calls = self.parser_instance.parse(
completion.text,
self.request,
enable_auto_tools=self.enable_auto_tools,
)
self.response_messages.extend(
build_response_output_items(
reasoning=reasoning,
content=content,
tool_calls=tool_calls,
tool_call_id_type=self.tool_call_id_type,
)
)
elif completion.text:
self.response_messages.append(
ResponseOutputMessage(
type="message",
id=f"msg_{random_uuid()}",
status="completed",
role="assistant",
content=[
ResponseOutputText(
annotations=[],
type="output_text",
text=completion.text,
logprobs=None,
)
],
)
)
self._accumulated_token_ids.extend(completion.token_ids or [])
if self.request.enable_response_messages:
output_prompt = output.prompt or ""
output_prompt_token_ids = output.prompt_token_ids or []
@@ -342,18 +387,18 @@ class ParsableContext(ConversationContext):
)
self.output_messages.append(
ResponseRawMessageAndToken(
message=output.outputs[0].text,
tokens=output.outputs[0].token_ids,
message=completion.text,
tokens=completion.token_ids,
)
)
def append_tool_output(self, output: list[ResponseInputOutputItem]) -> None:
self.parser.response_messages.extend(output)
self.response_messages.extend(output)
def need_builtin_tool_call(self) -> bool:
"""Return true if the last message is a builtin tool call
that the request has enabled."""
last_message = self.parser.response_messages[-1]
last_message = self.response_messages[-1]
if last_message.type != "function_call":
return False
if last_message.name in ("code_interpreter", "python"):
@@ -457,12 +502,12 @@ class ParsableContext(ConversationContext):
return [message]
async def call_tool(self) -> list[ResponseInputOutputItem]:
if not self.parser.response_messages:
if not self.response_messages:
return []
last_msg = self.parser.response_messages[-1]
last_msg = self.response_messages[-1]
# change this to a mcp_ function call
last_msg.id = f"{MCP_PREFIX}{random_uuid()}"
self.parser.response_messages[-1] = last_msg
self.response_messages[-1] = last_msg
if last_msg.name == "code_interpreter":
return await self.call_python_tool(self._tool_sessions["python"], last_msg)
elif last_msg.name == "web_search_preview":
@@ -473,6 +518,29 @@ class ParsableContext(ConversationContext):
)
return []
def make_response_output_items(self) -> list[ResponseOutputItem]:
response_messages = self.response_messages[self.num_init_messages :]
output_messages: list[ResponseOutputItem] = []
for message in response_messages:
if not isinstance(message, ResponseFunctionToolCallOutputItem):
output_messages.append(message)
else:
if len(output_messages) == 0:
raise ValueError(
"Cannot have a FunctionToolCallOutput before FunctionToolCall."
)
if isinstance(output_messages[-1], ResponseFunctionToolCall):
output_messages[-1] = McpCall(
id=f"{MCP_PREFIX}{random_uuid()}",
arguments=output_messages[-1].arguments,
name=output_messages[-1].name,
server_label=output_messages[-1].name,
type="mcp_call",
status="completed",
output=message.output,
)
return output_messages
def render_for_completion(self):
raise NotImplementedError("Should not be called.")