[Bugfix][Rust Frontend] Fix adjacent DeepSeek V4 user content rendering (#53281)

Co-authored-by: Bugen Zhao <i@bugenzhao.com>
Co-authored-by: OpenAI Codex <codex@openai.com>
Signed-off-by: reidliu41 <reid201711@gmail.com>
Signed-off-by: Bugen Zhao <i@bugenzhao.com>
This commit is contained in:
Reid
2026-09-01 00:23:24 +00:00
committed by GitHub
co-authored by Bugen Zhao OpenAI Codex
parent 89df6fcb80
commit d4329ba53d
2 changed files with 153 additions and 63 deletions
@@ -72,8 +72,9 @@ pub(super) fn render_request(request: &ChatRequest) -> Result<String> {
render_index += 1;
}
let mut last_tool_call_order = HashMap::new();
for (message_index, message) in request.messages.iter().enumerate() {
if is_following_tool_response(request.messages.as_slice(), message_index) {
if is_following_user_content(request.messages.as_slice(), message_index) {
continue;
}
@@ -93,7 +94,14 @@ pub(super) fn render_request(request: &ChatRequest) -> Result<String> {
ChatMessage::Developer { content, tools } => {
render_developer_message(&mut out, content, tools.as_deref().unwrap_or(&[]))?;
}
ChatMessage::User { content } => render_user_message(&mut out, content)?,
ChatMessage::User { .. } | ChatMessage::ToolResponse { .. } => {
render_user_content_block(
&mut out,
request.messages.as_slice(),
message_index,
&last_tool_call_order,
)?;
}
ChatMessage::Assistant { content } => {
// Mirror Python: thinking block (reasoning + </think>) is
// emitted whenever thinking is active and reasoning isn't
@@ -104,9 +112,16 @@ pub(super) fn render_request(request: &ChatRequest) -> Result<String> {
let append_eos = !(message_index + 1 == request.messages.len()
&& request.chat_options.continue_final_message());
render_assistant_message(&mut out, emit_thinking_block, append_eos, content)?;
}
ChatMessage::ToolResponse { .. } => {
render_tool_response_block(&mut out, request.messages.as_slice(), message_index)?;
if content.has_tool_calls() {
last_tool_call_order.clear();
last_tool_call_order.extend(
content
.tool_calls()
.enumerate()
.map(|(index, tool_call)| (tool_call.id.clone(), index)),
);
}
}
}
@@ -191,7 +206,7 @@ fn find_last_user_render_index(messages: &[ChatMessage], synthetic_tool_system:
let mut last_user_index = -1;
for (message_index, message) in messages.iter().enumerate() {
if is_following_tool_response(messages, message_index) {
if is_following_user_content(messages, message_index) {
continue;
}
@@ -204,14 +219,20 @@ fn find_last_user_render_index(messages: &[ChatMessage], synthetic_tool_system:
last_user_index
}
/// Return whether this tool message is already covered by a previous tool run.
fn is_following_tool_response(messages: &[ChatMessage], message_index: usize) -> bool {
matches!(messages[message_index], ChatMessage::ToolResponse { .. })
/// Return whether this message is already covered by a previous user-content
/// entry.
fn is_following_user_content(messages: &[ChatMessage], message_index: usize) -> bool {
is_user_content_entry(&messages[message_index])
&& message_index > 0
&& matches!(
messages[message_index - 1],
ChatMessage::ToolResponse { .. }
)
&& is_user_content_entry(&messages[message_index - 1])
}
/// Return whether one message contributes content to a V4 user turn.
fn is_user_content_entry(message: &ChatMessage) -> bool {
matches!(
message,
ChatMessage::User { .. } | ChatMessage::ToolResponse { .. }
)
}
/// Return whether one rendered entry should be treated as user-like.
@@ -226,10 +247,8 @@ fn is_user_like_entry(message: &ChatMessage) -> bool {
/// entry.
fn next_rendered_entry_is_assistant_or_end(messages: &[ChatMessage], message_index: usize) -> bool {
let mut next_index = message_index + 1;
if matches!(messages[message_index], ChatMessage::ToolResponse { .. }) {
while next_index < messages.len()
&& matches!(messages[next_index], ChatMessage::ToolResponse { .. })
{
if is_user_content_entry(&messages[message_index]) {
while next_index < messages.len() && is_user_content_entry(&messages[next_index]) {
next_index += 1;
}
}
@@ -329,47 +348,49 @@ fn render_developer_message(
Ok(())
}
/// Render one plain user turn.
fn render_user_message(out: &mut String, content: &ChatContent) -> Result<()> {
out.push_str(USER_SP_TOKEN);
write_chat_content(out, content)?;
Ok(())
}
/// Render a contiguous tool-response run as one synthetic user turn.
fn render_tool_response_block(
/// Render contiguous user and tool-response messages as one V4 user turn.
fn render_user_content_block(
out: &mut String,
messages: &[ChatMessage],
message_index: usize,
tool_call_order: &HashMap<String, usize>,
) -> Result<()> {
let (block_start, block_end) = tool_response_block_bounds(messages, message_index);
let sorted_indices = sorted_tool_response_indices(messages, block_start, block_end);
let (block_start, block_end) = user_content_block_bounds(messages, message_index);
let mut sorted_tool_indices =
sorted_tool_response_indices(messages, block_start, block_end, tool_call_order).into_iter();
out.push_str(USER_SP_TOKEN);
for (offset, message_index) in sorted_indices.iter().enumerate() {
for (offset, message_index) in (block_start..block_end).enumerate() {
if offset > 0 {
out.push_str("\n\n");
}
let ChatMessage::ToolResponse { content, .. } = &messages[*message_index] else {
unreachable!("tool response block should only contain tool messages");
};
write_tool_result(out, content)?;
match &messages[message_index] {
ChatMessage::User { content } => write_chat_content(out, content)?,
ChatMessage::ToolResponse { .. } => {
let sorted_index = sorted_tool_indices
.next()
.expect("tool response block should include this tool message");
let ChatMessage::ToolResponse { content, .. } = &messages[sorted_index] else {
unreachable!("sorted tool response index should reference a tool message");
};
write_tool_result(out, content)?;
}
_ => unreachable!("user content block should only contain user content messages"),
}
}
Ok(())
}
/// Return the contiguous tool-response block containing `actual_index`.
fn tool_response_block_bounds(messages: &[ChatMessage], actual_index: usize) -> (usize, usize) {
/// Return the contiguous user-content block containing `actual_index`.
fn user_content_block_bounds(messages: &[ChatMessage], actual_index: usize) -> (usize, usize) {
let mut block_start = actual_index;
while block_start > 0 && matches!(messages[block_start - 1], ChatMessage::ToolResponse { .. }) {
while block_start > 0 && is_user_content_entry(&messages[block_start - 1]) {
block_start -= 1;
}
let mut block_end = actual_index + 1;
while block_end < messages.len()
&& matches!(messages[block_end], ChatMessage::ToolResponse { .. })
{
while block_end < messages.len() && is_user_content_entry(&messages[block_end]) {
block_end += 1;
}
@@ -380,12 +401,15 @@ fn sorted_tool_response_indices(
messages: &[ChatMessage],
block_start: usize,
block_end: usize,
tool_call_order: &HashMap<String, usize>,
) -> Vec<usize> {
let Some(tool_call_order) = last_tool_call_order_before(messages, block_start) else {
return (block_start..block_end).collect();
};
let mut indices = (block_start..block_end)
.filter(|index| matches!(messages[*index], ChatMessage::ToolResponse { .. }))
.collect::<Vec<_>>();
if indices.len() <= 1 || tool_call_order.is_empty() {
return indices;
}
let mut indices = (block_start..block_end).collect::<Vec<_>>();
indices.sort_by_key(|index| {
let ChatMessage::ToolResponse { tool_call_id, .. } = &messages[*index] else {
unreachable!("tool response block should only contain tool messages");
@@ -395,26 +419,6 @@ fn sorted_tool_response_indices(
indices
}
fn last_tool_call_order_before(
messages: &[ChatMessage],
message_index: usize,
) -> Option<HashMap<&str, usize>> {
let mut tool_call_order = None;
for message in &messages[..message_index] {
if let ChatMessage::Assistant { content } = message {
let order = content
.tool_calls()
.enumerate()
.map(|(index, tool_call)| (tool_call.id.as_str(), index))
.collect::<HashMap<_, _>>();
if !order.is_empty() {
tool_call_order = Some(order);
}
}
}
tool_call_order
}
/// Render one tool response payload inside a V4 `<tool_result>` block.
fn write_tool_result(out: &mut String, content: &ChatContent) -> Result<()> {
out.push_str("<tool_result>");
@@ -323,6 +323,92 @@ fn tool_results_are_sorted_by_previous_assistant_tool_call_order() {
.assert_eq(&rendered);
}
#[test]
fn tool_response_and_following_user_share_one_turn() {
let mut request = ChatRequest {
messages: vec![
ChatMessage::tool_response("result", "call_1"),
ChatMessage::user("follow-up"),
],
..ChatRequest::for_test()
};
request
.chat_options
.template_kwargs
.insert("thinking".to_string(), Value::Bool(false));
let rendered = render_request(&request);
expect![
"<|begin▁of▁sentence|><|User|><tool_result>result</tool_result>\n\nfollow-up<|Assistant|></think>"
]
.assert_eq(&rendered);
}
#[test]
fn consecutive_users_share_one_turn() {
let mut request = ChatRequest {
messages: vec![ChatMessage::user("part 1"), ChatMessage::user("part 2")],
..ChatRequest::for_test()
};
request
.chat_options
.template_kwargs
.insert("thinking".to_string(), Value::Bool(false));
let rendered = render_request(&request);
expect!["<|begin▁of▁sentence|><|User|>part 1\n\npart 2<|Assistant|></think>"]
.assert_eq(&rendered);
}
#[test]
fn mixed_user_content_keeps_text_position_when_sorting_tool_results() {
let mut request = ChatRequest {
messages: vec![
ChatMessage::assistant_blocks(vec![
AssistantContentBlock::ToolCall(AssistantToolCall {
id: "second".to_string(),
name: "second_tool".to_string(),
arguments: "{}".to_string(),
}),
AssistantContentBlock::ToolCall(AssistantToolCall {
id: "first".to_string(),
name: "first_tool".to_string(),
arguments: "{}".to_string(),
}),
]),
ChatMessage::tool_response("first result", "first"),
ChatMessage::user("follow-up"),
ChatMessage::tool_response("second result", "second"),
],
..ChatRequest::for_test()
};
request
.chat_options
.template_kwargs
.insert("thinking".to_string(), Value::Bool(false));
let rendered = render_request(&request);
expect![[r#"
<|begin▁of▁sentence|>
<|DSML|tool_calls>
<|DSML|invoke name="second_tool">
</|DSML|invoke>
<|DSML|invoke name="first_tool">
</|DSML|invoke>
</|DSML|tool_calls><|end▁of▁sentence|><|User|><tool_result>second result</tool_result>
follow-up
<tool_result>first result</tool_result><|Assistant|></think>"#]]
.assert_eq(&rendered);
}
#[test]
fn drop_thinking_false_keeps_prior_assistant_reasoning() {
let mut request = ChatRequest {