[Bugfix][Frontend] streaming tool-call serializer drops first args chunk when name and args share a DeltaMessage (#42683)

Signed-off-by: ignaciosica <mignacio.sica@gmail.com>
Signed-off-by: sfeng33 <4florafeng@gmail.com>
Co-authored-by: sfeng33 <4florafeng@gmail.com>
This commit is contained in:
Ignacio Sica
2026-05-28 05:20:55 +00:00
committed by GitHub
co-authored by sfeng33
parent 626fa9bba5
commit 7909f82a45
4 changed files with 241 additions and 39 deletions
+12 -10
View File
@@ -85,6 +85,7 @@ from vllm.entrypoints.openai.responses.streaming_events import (
emit_content_delta_events,
emit_previous_item_done_events,
emit_tool_action_events,
split_delta,
)
from vllm.entrypoints.openai.responses.utils import (
construct_input_messages,
@@ -1414,18 +1415,19 @@ class OpenAIServingResponses(OpenAIServing):
if not delta_message:
continue
target_state, tool_call = processor.resolve_target_state(delta_message)
if target_state == _StateType.NONE:
continue
for dm in split_delta(delta_message):
target_state, tool_call = processor.resolve_target_state(dm)
if target_state == _StateType.NONE:
continue
if processor.needs_transition(target_state, tool_call):
for event in processor.close_current():
yield _increment_sequence_number_and_return(event)
for event in processor.open(target_state, tool_call):
yield _increment_sequence_number_and_return(event)
if processor.needs_transition(target_state, tool_call):
for event in processor.close_current():
yield _increment_sequence_number_and_return(event)
for event in processor.open(target_state, tool_call):
yield _increment_sequence_number_and_return(event)
for event in processor.emit_delta(delta_message, output, _get_logprobs):
yield _increment_sequence_number_and_return(event)
for event in processor.emit_delta(dm, output, _get_logprobs):
yield _increment_sequence_number_and_return(event)
for event in processor.close_current():
yield _increment_sequence_number_and_return(event)
@@ -61,7 +61,7 @@ from openai.types.responses.response_reasoning_item import (
from openai_harmony import Message as HarmonyMessage
from vllm.entrypoints.mcp.tool_server import ToolServer
from vllm.entrypoints.openai.engine.protocol import DeltaMessage
from vllm.entrypoints.openai.engine.protocol import DeltaMessage, DeltaToolCall
from vllm.entrypoints.openai.parser.harmony_utils import (
extract_function_from_recipient,
is_function_recipient,
@@ -1118,6 +1118,38 @@ class _StateHandlers(NamedTuple):
done_fn: Callable[..., list[StreamingResponsesResponse]]
def split_delta(delta: DeltaMessage) -> list[DeltaMessage]:
"""Decompose a DeltaMessage with multiple fields into atomic deltas.
The Responses API emits typed SSE events (one type per event), so a
compound DeltaMessage must be split before entering the state machine.
Order: reasoning -> content -> tool_calls (grouped by index).
"""
has_reasoning = delta.reasoning is not None
has_content = delta.content is not None
has_tools = bool(delta.tool_calls)
parts = int(has_reasoning) + int(has_content) + int(has_tools)
if parts <= 1 and (
not has_tools
or len({tc.index for tc in delta.tool_calls if tc.index is not None}) <= 1
):
return [delta]
deltas: list[DeltaMessage] = []
if has_reasoning:
deltas.append(DeltaMessage(reasoning=delta.reasoning))
if has_content:
deltas.append(DeltaMessage(content=delta.content))
if has_tools:
groups: dict[int | None, list[DeltaToolCall]] = {}
for tc in delta.tool_calls:
groups.setdefault(tc.index, []).append(tc)
for tcs in groups.values():
deltas.append(DeltaMessage(tool_calls=tcs))
return deltas or [delta]
class SimpleStreamingEventProcessor:
"""
State-machine processor for the simple (non-Harmony) streaming path.
@@ -1223,38 +1255,17 @@ class SimpleStreamingEventProcessor:
]
| None = None,
) -> list[StreamingResponsesResponse]:
"""
Emit incremental events for the current state from the delta.
Special case: when already in REASONING and the same delta also
carries content, we emit the reasoning delta, close reasoning,
open content, and then emit the content delta.
"""
"""Emit incremental events for the current state from the delta."""
handlers = self._STATE_HANDLERS[self.state.current_state]
events: list[StreamingResponsesResponse] = []
# Special case: reasoning -> content inside a single delta.
if (
self.state.current_state == _StateType.REASONING
and delta_message.reasoning is not None
and delta_message.content is not None
):
events.extend(handlers.delta_fn(self.state, delta_message.reasoning))
events.extend(self.close_current())
events.extend(self.open(_StateType.CONTENT))
content_handlers = self._STATE_HANDLERS[_StateType.CONTENT]
logprobs = get_logprobs(output) if get_logprobs else []
events.extend(
content_handlers.delta_fn(self.state, delta_message.content, logprobs)
)
return events
if self.state.current_state == _StateType.TOOL_CALL:
assert delta_message.tool_calls is not None
tool_call_function = delta_message.tool_calls[0].function
assert tool_call_function is not None
if tool_call_function.arguments:
return handlers.delta_fn(self.state, tool_call_function.arguments)
combined_args = ""
for tc in delta_message.tool_calls:
if tc.function is not None and tc.function.arguments:
combined_args += tc.function.arguments
if combined_args:
return handlers.delta_fn(self.state, combined_args)
return []
elif self.state.current_state == _StateType.REASONING:
assert delta_message.reasoning is not None