From 59d7fc92ea038544959aae020a8b28fc34159545 Mon Sep 17 00:00:00 2001 From: Jiahao Liang Date: Tue, 25 Aug 2026 15:49:44 +0800 Subject: [PATCH] [Bugfix][DeepSeek V4] Handle trailing system messages in prompt rendering (#51262) Signed-off-by: jiahaoliang Signed-off-by: Jiahao Liang Co-authored-by: Chauncey --- .../chat/src/renderer/deepseek_v4/encoding.rs | 4 +- .../chat/src/renderer/deepseek_v4/tests.rs | 62 +++++++++++++++ tests/tokenizers_/test_deepseek_v4.py | 77 +++++++++++++++++++ vllm/tokenizers/deepseek_v4_encoding.py | 10 ++- 4 files changed, 150 insertions(+), 3 deletions(-) diff --git a/rust/src/chat/src/renderer/deepseek_v4/encoding.rs b/rust/src/chat/src/renderer/deepseek_v4/encoding.rs index c0bea8260a..5ea88c5665 100644 --- a/rust/src/chat/src/renderer/deepseek_v4/encoding.rs +++ b/rust/src/chat/src/renderer/deepseek_v4/encoding.rs @@ -110,7 +110,7 @@ pub(super) fn render_request(request: &ChatRequest) -> Result { } } - if is_user_like_entry(message) + if (is_user_like_entry(message) || matches!(message, ChatMessage::System { .. })) && next_rendered_entry_is_assistant_or_end(request.messages.as_slice(), message_index) { write_assistant_transition( @@ -423,7 +423,7 @@ fn write_tool_result(out: &mut String, content: &ChatContent) -> Result<()> { Ok(()) } -/// Append the assistant transition token after a user-like turn. +/// Append the assistant transition token after a user-like or system turn. fn write_assistant_transition( out: &mut String, thinking_mode: ThinkingMode, diff --git a/rust/src/chat/src/renderer/deepseek_v4/tests.rs b/rust/src/chat/src/renderer/deepseek_v4/tests.rs index ee054a3ac9..d41e040a85 100644 --- a/rust/src/chat/src/renderer/deepseek_v4/tests.rs +++ b/rust/src/chat/src/renderer/deepseek_v4/tests.rs @@ -195,6 +195,68 @@ fn reasoning_effort_none_disables_thinking() { .assert_eq(&rendered); } +#[test] +fn system_to_assistant_transitions_in_chat_and_thinking_modes() { + let rendered = [false, true].map(|enable_thinking| { + let mut request = ChatRequest { + messages: vec![ + ChatMessage::system("rules"), + ChatMessage::assistant_blocks(vec![ + AssistantContentBlock::Reasoning { + text: "reason".to_string(), + }, + AssistantContentBlock::Text { + text: "answer".to_string(), + }, + ]), + ], + ..ChatRequest::for_test() + }; + request + .chat_options + .template_kwargs + .insert("enable_thinking".to_string(), Value::Bool(enable_thinking)); + request.chat_options.reasoning_effort = Some(ReasoningEffort::Low); + render_request(&request) + }); + + expect![[r#" + [ + "<|begin▁of▁sentence|>rules<|Assistant|>answer<|end▁of▁sentence|>", + "<|begin▁of▁sentence|>rules<|Assistant|>reasonanswer<|end▁of▁sentence|>", + ] + "#]] + .assert_debug_eq(&rendered); +} + +#[test] +fn trailing_system_transitions_in_chat_and_thinking_modes() { + let rendered = [false, true].map(|enable_thinking| { + let mut request = ChatRequest { + messages: vec![ + ChatMessage::system("rules"), + ChatMessage::user("question"), + ChatMessage::system("final rules"), + ], + ..ChatRequest::for_test() + }; + request + .chat_options + .template_kwargs + .insert("enable_thinking".to_string(), Value::Bool(enable_thinking)); + request.chat_options.reasoning_effort = Some(ReasoningEffort::Low); + render_request(&request) + }); + + expect![[r#" + [ + "<|begin▁of▁sentence|>rules<|User|>questionfinal rules<|Assistant|>", + "<|begin▁of▁sentence|>rules<|User|>questionfinal rules<|Assistant|>", + ] + "#]] + .assert_debug_eq(&rendered); +} + #[test] fn reasoning_effort_template_kwarg_is_ignored() { let mut request = ChatRequest { diff --git a/tests/tokenizers_/test_deepseek_v4.py b/tests/tokenizers_/test_deepseek_v4.py index fd1ba94054..d452d1d7fe 100644 --- a/tests/tokenizers_/test_deepseek_v4.py +++ b/tests/tokenizers_/test_deepseek_v4.py @@ -113,6 +113,83 @@ def test_deepseek_v4_explicitly_disables_thinking(kwargs): assert prompt == ("<|begin▁of▁sentence|><|User|>Hello<|Assistant|>") +@pytest.mark.parametrize( + ("enable_thinking", "thinking_token"), + [(False, ""), (True, "")], +) +def test_deepseek_v4_appends_assistant_transition_after_trailing_system( + enable_thinking, thinking_token +): + prompt = _tokenizer().apply_chat_template( + [ + {"role": "system", "content": "You are helpful."}, + {"role": "user", "content": "What is 2+2?"}, + {"role": "system", "content": "Be concise."}, + ], + tokenize=False, + enable_thinking=enable_thinking, + reasoning_effort="low", + ) + + assert prompt == ( + "<|begin▁of▁sentence|>You are helpful." + f"<|User|>What is 2+2?Be concise.<|Assistant|>{thinking_token}" + ) + + +def test_deepseek_v4_does_not_transition_after_mid_conversation_system(): + prompt = _tokenizer().apply_chat_template( + [ + {"role": "user", "content": "What is 3+3?"}, + {"role": "assistant", "content": "6"}, + {"role": "system", "content": "Answer in French."}, + {"role": "user", "content": "What is 5+5?"}, + ], + tokenize=False, + enable_thinking=False, + ) + + assert prompt == ( + "<|begin▁of▁sentence|><|User|>What is 3+3?" + "<|Assistant|>6<|end▁of▁sentence|>" + "Answer in French.<|User|>What is 5+5?" + "<|Assistant|>" + ) + + +@pytest.mark.parametrize( + ("enable_thinking", "expected"), + [ + ( + False, + "<|begin▁of▁sentence|>rules<|Assistant|>answer" + "<|end▁of▁sentence|>", + ), + ( + True, + "<|begin▁of▁sentence|>rules<|Assistant|>reasonanswer" + "<|end▁of▁sentence|>", + ), + ], +) +def test_deepseek_v4_transitions_from_system_to_assistant(enable_thinking, expected): + prompt = _tokenizer().apply_chat_template( + [ + {"role": "system", "content": "rules"}, + { + "role": "assistant", + "reasoning": "reason", + "content": "answer", + }, + ], + tokenize=False, + enable_thinking=enable_thinking, + reasoning_effort="low", + ) + + assert prompt == expected + + def test_deepseek_v4_unknown_role_raises_value_error(): # Invalid roles are client errors: they must surface as ValueError # (mapped to HTTP 400 by the OpenAI serving layer), not diff --git a/vllm/tokenizers/deepseek_v4_encoding.py b/vllm/tokenizers/deepseek_v4_encoding.py index ceb702d3a0..6c0f804724 100644 --- a/vllm/tokenizers/deepseek_v4_encoding.py +++ b/vllm/tokenizers/deepseek_v4_encoding.py @@ -374,7 +374,15 @@ def render_message( prompt += thinking_end_token if thinking_mode != "thinking" else thinking_start_token prompt += task_sp_token - elif messages[index].get("role") in ["user", "developer"]: + # A trailing system message opens generation, while a system message + # followed by assistant opens that assistant history turn. + elif role in ["user", "developer"] or ( + role == "system" + and ( + index == len(messages) - 1 + or messages[index + 1].get("role") == "assistant" + ) + ): # Normal generation: append Assistant + thinking token prompt += ASSISTANT_SP_TOKEN if not drop_thinking and thinking_mode == "thinking":