[Rust Frontend] Support chat message names

rust/src/chat/src/backend/hf.rs

@@ -236,6 +236,7 @@ mod tests {
             request_id: "renderer-selection-test".to_string(),
             messages: vec![ChatMessage::User {
                 content: ChatContent::Text(text.to_string()),
+                name: None,
             }],
             ..ChatRequest::for_test()
         }

rust/src/chat/src/multimodal.rs

@@ -629,9 +629,9 @@ fn extract_media_parts(
                 )
             })?;
             let content = match message {
-                ChatMessage::System { content }
+                ChatMessage::System { content, .. }
                 | ChatMessage::Developer { content, .. }
-                | ChatMessage::User { content }
+                | ChatMessage::User { content, .. }
                 | ChatMessage::ToolResponse { content, .. }
                 | ChatMessage::Custom { content, .. } => content,
                 ChatMessage::Assistant { .. } => {
@@ -653,9 +653,9 @@ fn extract_media_parts(
         // Fall back to all media in request message and content-part order (e.g. Jinja).
         None => Either::Right(request.messages.iter().flat_map(|message| {
             let content = match message {
-                ChatMessage::System { content }
+                ChatMessage::System { content, .. }
                 | ChatMessage::Developer { content, .. }
-                | ChatMessage::User { content }
+                | ChatMessage::User { content, .. }
                 | ChatMessage::ToolResponse { content, .. }
                 | ChatMessage::Custom { content, .. } => Some(content),
                 ChatMessage::Assistant { .. } => None,

rust/src/chat/src/renderer/deepseek.rs

@@ -162,7 +162,7 @@ pub(super) fn render_request_with_media_order(
         render_index += 1;
 
         match message {
-            ChatMessage::System { content } => {
+            ChatMessage::System { content, .. } => {
                 if dialect == DsDialect::V41 && current_render_index > 0 {
                     out.push_str(SYSTEM_SP_TOKEN);
                 }
@@ -180,7 +180,7 @@ pub(super) fn render_request_with_media_order(
                     &mut media_order,
                 )?;
             }
-            ChatMessage::Developer { content, tools } => {
+            ChatMessage::Developer { content, tools, .. } => {
                 render_developer_message(
                     &mut out,
                     message_index,
@@ -200,7 +200,7 @@ pub(super) fn render_request_with_media_order(
                     &mut media_order,
                 )?;
             }
-            ChatMessage::Assistant { content } => {
+            ChatMessage::Assistant { content, .. } => {
                 // Mirror Python: thinking block (reasoning + </think>) is
                 // emitted whenever thinking is active and reasoning isn't
                 // dropped - i.e. drop_thinking is off OR this turn lies
@@ -436,17 +436,17 @@ fn starts_user_turn(
 fn reject_image_placeholder_text(messages: &[ChatMessage]) -> Result<()> {
     let has_placeholder = |text: &str| text.contains(DEEPSEEK_V41_IMAGE_PLACEHOLDER);
     let found = messages.iter().any(|message| match message {
-        ChatMessage::System { content }
+        ChatMessage::System { content, .. }
         | ChatMessage::Developer { content, .. }
-        | ChatMessage::User { content }
+        | ChatMessage::User { content, .. }
         | ChatMessage::ToolResponse { content, .. }
         | ChatMessage::Custom { content, .. } => match content {
             ChatContent::Text(text) => has_placeholder(text),
             ChatContent::Parts(parts) => parts.iter().any(
                 |part| matches!(part, ChatContentPart::Text { text } if has_placeholder(text)),
             ),
         },
-        ChatMessage::Assistant { content } => content.iter().any(|block| {
+        ChatMessage::Assistant { content, .. } => content.iter().any(|block| {
             matches!(
                 block,
                 AssistantContentBlock::Text { text } | AssistantContentBlock::Reasoning { text }
@@ -617,7 +617,7 @@ fn render_user_content_block(
             out.push_str("\n\n");
         }
         match &messages[message_index] {
-            ChatMessage::User { content } => {
+            ChatMessage::User { content, .. } => {
                 write_chat_content(out, content, dialect, message_index, media_order)?;
             }
             ChatMessage::ToolResponse { .. } => {

rust/src/chat/src/renderer/deepseek_v32/encoding.rs

@@ -125,21 +125,21 @@ fn render_message(
     let add_generation_prompt = message_index + 1 != messages.len() || add_generation_prompt;
 
     match message {
-        ChatMessage::System { content } => render_system_message(out, Some(content), &[]),
-        ChatMessage::Developer { content, tools } => render_developer_message(
+        ChatMessage::System { content, .. } => render_system_message(out, Some(content), &[]),
+        ChatMessage::Developer { content, tools, .. } => render_developer_message(
             out,
             content,
             tools.as_deref().unwrap_or(&[]),
             thinking_mode == ThinkingMode::Thinking && opens_thinking,
             add_generation_prompt,
         ),
-        ChatMessage::User { content } => render_user_message(
+        ChatMessage::User { content, .. } => render_user_message(
             out,
             content,
             thinking_mode == ThinkingMode::Thinking && opens_thinking,
             add_generation_prompt,
         ),
-        ChatMessage::Assistant { content } => render_assistant_message(
+        ChatMessage::Assistant { content, .. } => render_assistant_message(
             out,
             thinking_mode == ThinkingMode::Thinking && after_last_user_turn,
             content,
@@ -275,6 +275,7 @@ fn render_tool_message(
 
     let ChatMessage::Assistant {
         content: assistant_content,
+        ..
     } = &messages[prev_assistant_idx]
     else {
         return Err(Error::ChatTemplate(
@@ -305,6 +306,7 @@ fn render_tool_message(
         let ChatMessage::ToolResponse {
             content,
             tool_call_id,
+            ..
         } = message
         else {
             unreachable!("tool response block should only contain tool messages");

rust/src/chat/src/renderer/deepseek_v41/tests.rs

@@ -72,6 +72,7 @@ fn inlines_image_placeholder_at_image_part_positions() {
                 ChatContentPart::image_url("https://example.com/carrots.jpeg"),
                 ChatContentPart::text("what is in the image?"),
             ]),
+            name: None,
         }],
         ..ChatRequest::for_test()
     };

rust/src/chat/src/renderer/harmony/mod.rs

@@ -180,8 +180,10 @@ fn peel_leading_instructions(
     };
 
     match first {
-        ChatMessage::System { content } => Ok((Some(flatten_text(content)?), None, &messages[1..])),
-        ChatMessage::Developer { content, tools } => Ok((
+        ChatMessage::System { content, .. } => {
+            Ok((Some(flatten_text(content)?), None, &messages[1..]))
+        }
+        ChatMessage::Developer { content, tools, .. } => Ok((
             Some(flatten_text(content)?),
             tools.as_deref(),
             &messages[1..],
@@ -291,7 +293,7 @@ fn to_harmony_message(
     options: &Options,
 ) -> Result<Vec<Message>> {
     Ok(match message {
-        ChatMessage::System { content } => {
+        ChatMessage::System { content, .. } => {
             let instructions = flatten_text(content)?;
             vec![system_or_developer_message(
                 "system",
@@ -300,20 +302,21 @@ fn to_harmony_message(
                 options,
             )?]
         }
-        ChatMessage::Developer { content, tools } => {
+        ChatMessage::Developer { content, tools, .. } => {
             let instructions = flatten_text(content)?;
             vec![developer_message(Some(instructions), tools.as_deref())]
         }
-        ChatMessage::User { content } => {
+        ChatMessage::User { content, .. } => {
             vec![Message::from_role_and_content(
                 Role::User,
                 flatten_text(content)?,
             )]
         }
-        ChatMessage::Assistant { content } => assistant_messages(content),
+        ChatMessage::Assistant { content, .. } => assistant_messages(content),
         ChatMessage::ToolResponse {
             content,
             tool_call_id,
+            ..
         } => {
             let name = tool_call_names.get(tool_call_id).ok_or_else(|| {
                 Error::ChatTemplate(format!(
@@ -420,7 +423,7 @@ fn assistant_messages(content: &[AssistantContentBlock]) -> Vec<Message> {
 fn tool_call_names(messages: &[ChatMessage]) -> std::collections::HashMap<String, String> {
     let mut names = std::collections::HashMap::new();
     for message in messages {
-        let ChatMessage::Assistant { content } = message else {
+        let ChatMessage::Assistant { content, .. } = message else {
             continue;
         };
         for tool_call in content.tool_calls() {

rust/src/chat/src/renderer/hf/mod.rs

@@ -278,6 +278,8 @@ struct TemplateMessage<'a> {
     tool_calls: Option<Vec<TemplateToolCall>>,
     // Tool-role messages refer back to the assistant call they are answering.
     tool_call_id: Option<String>,
+    // Optional participant name, passed through for any role.
+    name: Option<&'a str>,
 }
 
 /// Chat content in the two shapes HF templates commonly expect.
@@ -345,35 +347,39 @@ fn to_template_message<'a>(
     content_format: ChatTemplateContentFormat,
     multimodal: Option<&MultimodalRenderInfo>,
 ) -> Result<TemplateMessage<'a>> {
+    let name = message.name();
     Ok(match message {
-        ChatMessage::System { content } => TemplateMessage {
+        ChatMessage::System { content, .. } => TemplateMessage {
             role: "system",
             content: to_template_content(content, content_format, multimodal)?,
             tools: None,
             reasoning: None,
             reasoning_content: None,
             tool_calls: None,
             tool_call_id: None,
+            name,
         },
-        ChatMessage::Developer { content, tools } => TemplateMessage {
+        ChatMessage::Developer { content, tools, .. } => TemplateMessage {
             role: "developer",
             content: to_template_content(content, content_format, multimodal)?,
             tools: tools.as_deref().map(to_template_tools),
             reasoning: None,
             reasoning_content: None,
             tool_calls: None,
             tool_call_id: None,
+            name,
         },
-        ChatMessage::User { content } => TemplateMessage {
+        ChatMessage::User { content, .. } => TemplateMessage {
             role: "user",
             content: to_template_content(content, content_format, multimodal)?,
             tools: None,
             reasoning: None,
             reasoning_content: None,
             tool_calls: None,
             tool_call_id: None,
+            name,
         },
-        ChatMessage::Assistant { content } => {
+        ChatMessage::Assistant { content, .. } => {
             let text = content.text();
             let reasoning = content.reasoning();
             let tool_calls = to_template_tool_calls(content)?;
@@ -387,11 +393,13 @@ fn to_template_message<'a>(
                 reasoning_content: reasoning,
                 tool_calls,
                 tool_call_id: None,
+                name,
             }
         }
         ChatMessage::ToolResponse {
             content,
             tool_call_id,
+            ..
         } => TemplateMessage {
             role: "tool",
             content: to_template_content(content, content_format, multimodal)?,
@@ -400,15 +408,17 @@ fn to_template_message<'a>(
             reasoning_content: None,
             tool_calls: None,
             tool_call_id: Some(tool_call_id.clone()),
+            name,
         },
-        ChatMessage::Custom { role, content } => TemplateMessage {
+        ChatMessage::Custom { role, content, .. } => TemplateMessage {
             role,
             content: to_template_content(content, content_format, multimodal)?,
             tools: None,
             reasoning: None,
             reasoning_content: None,
             tool_calls: None,
             tool_call_id: None,
+            name,
         },
     })
 }
@@ -1055,6 +1065,32 @@ mod tests {
         assert_eq!(rendered, "root=identity;system=policy;user=hello;");
     }
 
+    #[test]
+    fn chat_template_passes_message_names_for_every_role() {
+        let request = sample_request(vec![
+            ChatMessage::custom("root", "identity").with_name(Some("operator".to_string())),
+            ChatMessage::system("policy").with_name(Some("rules".to_string())),
+            ChatMessage::developer("notes", None).with_name(Some("dev".to_string())),
+            ChatMessage::user("hello").with_name(Some("alice".to_string())),
+            ChatMessage::user("hi"),
+            ChatMessage::assistant_text("hey").with_name(Some("helper".to_string())),
+            ChatMessage::tool_response("sunny", "call_1").with_name(Some("weather".to_string())),
+        ]);
+
+        let rendered = render(
+            Some(
+                "{% for m in messages %}{{ m.role }}:{{ m.name if m.name is defined else '-' }};{% endfor %}",
+            ),
+            &request,
+        )
+        .unwrap();
+
+        assert_eq!(
+            rendered,
+            "root:operator;system:rules;developer:dev;user:alice;user:-;assistant:helper;tool:weather;"
+        );
+    }
+
     #[test]
     fn chat_template_keeps_string_text_for_openai_detected_templates() {
         let request = sample_request(vec![ChatMessage::text(ChatRole::User, "hello")]);

rust/src/chat/src/renderer/inkling/mod.rs

@@ -322,21 +322,22 @@ impl ChatRenderer for InklingChatRenderer {
             }
 
             match message {
-                ChatMessage::System { content } => {
+                ChatMessage::System { content, .. } => {
                     self.write_chat_content(&mut out, self.special.message_system, content)?;
                 }
                 ChatMessage::Developer { content, .. } => {
                     self.write_chat_content(&mut out, self.special.message_system, content)?;
                 }
-                ChatMessage::User { content } => {
+                ChatMessage::User { content, .. } => {
                     self.write_chat_content(&mut out, self.special.message_user, content)?;
                 }
-                ChatMessage::Assistant { content } => {
+                ChatMessage::Assistant { content, .. } => {
                     self.write_assistant_content(&mut out, content, &mut tool_call_id_to_name)?;
                 }
                 ChatMessage::ToolResponse {
                     content,
                     tool_call_id,
+                    ..
                 } => {
                     self.write_tool_response(
                         &mut out,

rust/src/chat/src/renderer/kimi_k3/encoding.rs

@@ -122,6 +122,7 @@ pub(super) fn render_request_with_media_order(
             let ChatMessage::ToolResponse {
                 content,
                 tool_call_id,
+                ..
             } = message
             else {
                 unreachable!("pending tool run only holds tool responses");
@@ -176,19 +177,20 @@ pub(super) fn render_request_with_media_order(
             ChatMessage::Developer {
                 content,
                 tools: Some(local_tools),
+                ..
             } if !local_tools.is_empty() => {
                 write_tool_declare(&mut out, local_tools, true)?;
                 if !content_is_empty(content) {
                     write_role_message(&mut out, "system", None, message_index, content)?;
                 }
             }
-            ChatMessage::System { content } | ChatMessage::Developer { content, .. } => {
+            ChatMessage::System { content, .. } | ChatMessage::Developer { content, .. } => {
                 write_role_message(&mut out, "system", None, message_index, content)?;
             }
-            ChatMessage::User { content } => {
+            ChatMessage::User { content, .. } => {
                 write_role_message(&mut out, "user", None, message_index, content)?;
             }
-            ChatMessage::Assistant { content } => {
+            ChatMessage::Assistant { content, .. } => {
                 tool_call_id_index.clear();
                 let mut call_position = 0usize;
                 for block in content {