apunkt/plano
1
0
Fork 0
mirror of https://github.com/katanemo/plano.git synced 2026-06-29 15:49:40 +02:00
Code Issues Projects Releases Packages Wiki Activity

making Messages.Content optional, and having the upstream LLM fail if the right fields aren't set

Browse source
This commit is contained in:
Salman Paracha 2026-01-16 16:11:09 -08:00
parent 4d53297c17
commit bdb26f4491
17 changed files with 294 additions and 133 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/brightstaff/src/handlers/agent_chat_completions.rs
View file

@ -402,7 +402,7 @@ async fn handle_agent_chat(
// and add it to the conversation history // and add it to the conversation history
current_messages.push(OpenAIMessage { current_messages.push(OpenAIMessage {
role: hermesllm::apis::openai::Role::Assistant, role: hermesllm::apis::openai::Role::Assistant,
content: hermesllm::apis::openai::MessageContent::Text(response_text), content: Some(hermesllm::apis::openai::MessageContent::Text(response_text)),
name: Some(agent_name.clone()), name: Some(agent_name.clone()),
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,

20
crates/brightstaff/src/handlers/function_calling.rs
View file

@ -638,7 +638,7 @@ impl ArchFunctionHandler {
let system_prompt = self.format_system_prompt(tools)?; let system_prompt = self.format_system_prompt(tools)?;
processed_messages.push(Message { processed_messages.push(Message {
role: Role::System, role: Role::System,
content: MessageContent::Text(system_prompt), content: Some(MessageContent::Text(system_prompt)),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -649,8 +649,9 @@ impl ArchFunctionHandler {
for (idx, message) in messages.iter().enumerate() { for (idx, message) in messages.iter().enumerate() {
let mut role = message.role.clone(); let mut role = message.role.clone();
let mut content = match &message.content { let mut content = match &message.content {
MessageContent::Text(text) => text.clone(), Some(MessageContent::Text(text)) => text.clone(),
MessageContent::Parts(_) => String::new(), Some(MessageContent::Parts(_)) => String::new(),
None => String::new(),
}; };
// Handle tool calls // Handle tool calls
@ -675,7 +676,8 @@ impl ArchFunctionHandler {
} else { } else {
// Get the tool call from previous message // Get the tool call from previous message
if idx > 0 { if idx > 0 {
if let MessageContent::Text(prev_content) = &messages[idx - 1].content { if let Some(MessageContent::Text(prev_content)) = &messages[idx - 1].content
{
let mut tool_call_msg = prev_content.clone(); let mut tool_call_msg = prev_content.clone();
// Strip markdown code blocks // Strip markdown code blocks
@ -721,7 +723,7 @@ impl ArchFunctionHandler {
processed_messages.push(Message { processed_messages.push(Message {
role, role,
content: MessageContent::Text(content), content: Some(MessageContent::Text(content)),
name: message.name.clone(), name: message.name.clone(),
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -740,7 +742,7 @@ impl ArchFunctionHandler {
// Add extra instruction if provided // Add extra instruction if provided
if let Some(instruction) = extra_instruction { if let Some(instruction) = extra_instruction {
if let Some(last) = processed_messages.last_mut() { if let Some(last) = processed_messages.last_mut() {
if let MessageContent::Text(content) = &mut last.content { if let Some(MessageContent::Text(content)) = &mut last.content {
content.push('\n'); content.push('\n');
content.push_str(instruction); content.push_str(instruction);
} }
@ -761,7 +763,7 @@ impl ArchFunctionHandler {
// Keep system message if present // Keep system message if present
if let Some(first) = messages.first() { if let Some(first) = messages.first() {
if first.role == Role::System { if first.role == Role::System {
if let MessageContent::Text(content) = &first.content { if let Some(MessageContent::Text(content)) = &first.content {
num_tokens += content.len() / 4; // Approximate 4 chars per token num_tokens += content.len() / 4; // Approximate 4 chars per token
} }
conversation_idx = 1; conversation_idx = 1;
@ -772,7 +774,7 @@ impl ArchFunctionHandler {
// Start with message_idx pointing past the end (will be used if no truncation needed) // Start with message_idx pointing past the end (will be used if no truncation needed)
let mut message_idx = messages.len(); let mut message_idx = messages.len();
for i in (conversation_idx..messages.len()).rev() { for i in (conversation_idx..messages.len()).rev() {
if let MessageContent::Text(content) = &messages[i].content { if let Some(MessageContent::Text(content)) = &messages[i].content {
num_tokens += content.len() / 4; num_tokens += content.len() / 4;
if num_tokens >= max_tokens && messages[i].role == Role::User { if num_tokens >= max_tokens && messages[i].role == Role::User {
// Set message_idx to current position and break // Set message_idx to current position and break
@ -802,7 +804,7 @@ impl ArchFunctionHandler {
pub fn prefill_message(&self, mut messages: Vec<Message>, prefill: &str) -> Vec<Message> { pub fn prefill_message(&self, mut messages: Vec<Message>, prefill: &str) -> Vec<Message> {
messages.push(Message { messages.push(Message {
role: Role::Assistant, role: Role::Assistant,
content: MessageContent::Text(prefill.to_string()), content: Some(MessageContent::Text(prefill.to_string())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,

4
crates/brightstaff/src/handlers/integration_tests.rs
View file

@ -28,7 +28,7 @@ mod tests {
fn create_test_message(role: Role, content: &str) -> Message { fn create_test_message(role: Role, content: &str) -> Message {
Message { Message {
role, role,
content: MessageContent::Text(content.to_string()), content: Some(MessageContent::Text(content.to_string())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -129,7 +129,7 @@ mod tests {
let processed_messages = result.unwrap(); let processed_messages = result.unwrap();
// With empty filter chain, should return the original messages unchanged // With empty filter chain, should return the original messages unchanged
assert_eq!(processed_messages.len(), 1); assert_eq!(processed_messages.len(), 1);
if let MessageContent::Text(content) = &processed_messages[0].content { if let Some(MessageContent::Text(content)) = &processed_messages[0].content {
assert_eq!(content, "Hello world!"); assert_eq!(content, "Hello world!");
} else { } else {
panic!("Expected text content"); panic!("Expected text content");

2
crates/brightstaff/src/handlers/pipeline_processor.rs
View file

@ -887,7 +887,7 @@ mod tests {
fn create_test_message(role: Role, content: &str) -> Message { fn create_test_message(role: Role, content: &str) -> Message {
Message { Message {
role, role,
content: MessageContent::Text(content.to_string()), content: Some(MessageContent::Text(content.to_string())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,

4
crates/brightstaff/src/handlers/router_chat.rs
View file

@ -95,7 +95,9 @@ pub async fn router_chat_get_upstream_model(
.messages .messages
.last() .last()
.map_or("None".to_string(), |msg| { .map_or("None".to_string(), |msg| {
msg.content.to_string().replace('\n', "\\n") msg.content
.as_ref()
.map_or("None".to_string(), |c| c.to_string().replace('\n', "\\n"))
}); });
const MAX_MESSAGE_LENGTH: usize = 50; const MAX_MESSAGE_LENGTH: usize = 50;

30
crates/brightstaff/src/router/orchestrator_model_v1.rs
View file

@ -2,6 +2,7 @@ use std::collections::HashMap;
use common::configuration::{AgentUsagePreference, OrchestrationPreference}; use common::configuration::{AgentUsagePreference, OrchestrationPreference};
use hermesllm::apis::openai::{ChatCompletionsRequest, Message, MessageContent, Role}; use hermesllm::apis::openai::{ChatCompletionsRequest, Message, MessageContent, Role};
use hermesllm::transforms::lib::ExtractText;
use serde::{ser::Serialize as SerializeTrait, Deserialize, Serialize}; use serde::{ser::Serialize as SerializeTrait, Deserialize, Serialize};
use tracing::{debug, warn}; use tracing::{debug, warn};
@ -181,7 +182,9 @@ impl OrchestratorModel for OrchestratorModelV1 {
let messages_vec = messages let messages_vec = messages
.iter() .iter()
.filter(|m| { .filter(|m| {
m.role != Role::System && m.role != Role::Tool && !m.content.to_string().is_empty() m.role != Role::System
&& m.role != Role::Tool
&& !m.content.extract_text().is_empty()
}) })
.collect::<Vec<&Message>>(); .collect::<Vec<&Message>>();
@ -190,7 +193,7 @@ impl OrchestratorModel for OrchestratorModelV1 {
let mut token_count = ARCH_ORCHESTRATOR_V1_SYSTEM_PROMPT.len() / TOKEN_LENGTH_DIVISOR; let mut token_count = ARCH_ORCHESTRATOR_V1_SYSTEM_PROMPT.len() / TOKEN_LENGTH_DIVISOR;
let mut selected_messages_list_reversed: Vec<&Message> = vec![]; let mut selected_messages_list_reversed: Vec<&Message> = vec![];
for (selected_messsage_count, message) in messages_vec.iter().rev().enumerate() { for (selected_messsage_count, message) in messages_vec.iter().rev().enumerate() {
let message_token_count = message.content.to_string().len() / TOKEN_LENGTH_DIVISOR; let message_token_count = message.content.extract_text().len() / TOKEN_LENGTH_DIVISOR;
token_count += message_token_count; token_count += message_token_count;
if token_count > self.max_token_length { if token_count > self.max_token_length {
debug!( debug!(
@ -240,7 +243,12 @@ impl OrchestratorModel for OrchestratorModelV1 {
.rev() .rev()
.map(|message| Message { .map(|message| Message {
role: message.role.clone(), role: message.role.clone(),
content: MessageContent::Text(message.content.to_string()), content: Some(MessageContent::Text(
message
.content
.as_ref()
.map_or(String::new(), |c| c.to_string()),
)),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -262,7 +270,7 @@ impl OrchestratorModel for OrchestratorModelV1 {
ChatCompletionsRequest { ChatCompletionsRequest {
model: self.orchestration_model.clone(), model: self.orchestration_model.clone(),
messages: vec![Message { messages: vec![Message {
content: MessageContent::Text(orchestrator_message), content: Some(MessageContent::Text(orchestrator_message)),
role: Role::User, role: Role::User,
name: None, name: None,
tool_calls: None, tool_calls: None,
@ -539,7 +547,7 @@ If no routes are needed, return an empty list for `route`.
let req = orchestrator.generate_request(&conversation, &None); let req = orchestrator.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -618,7 +626,7 @@ If no routes are needed, return an empty list for `route`.
}]); }]);
let req = orchestrator.generate_request(&conversation, &usage_preferences); let req = orchestrator.generate_request(&conversation, &usage_preferences);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -689,7 +697,7 @@ If no routes are needed, return an empty list for `route`.
let req = orchestrator.generate_request(&conversation, &None); let req = orchestrator.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -761,7 +769,7 @@ If no routes are needed, return an empty list for `route`.
let req = orchestrator.generate_request(&conversation, &None); let req = orchestrator.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -848,7 +856,7 @@ If no routes are needed, return an empty list for `route`.
let req = orchestrator.generate_request(&conversation, &None); let req = orchestrator.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -940,7 +948,7 @@ If no routes are needed, return an empty list for `route`.
let req = orchestrator.generate_request(&conversation, &None); let req = orchestrator.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -1058,7 +1066,7 @@ If no routes are needed, return an empty list for `route`.
let req: ChatCompletionsRequest = orchestrator.generate_request(&conversation, &None); let req: ChatCompletionsRequest = orchestrator.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }

30
crates/brightstaff/src/router/router_model_v1.rs
View file

@ -2,6 +2,7 @@ use std::collections::HashMap;
use common::configuration::{ModelUsagePreference, RoutingPreference}; use common::configuration::{ModelUsagePreference, RoutingPreference};
use hermesllm::apis::openai::{ChatCompletionsRequest, Message, MessageContent, Role}; use hermesllm::apis::openai::{ChatCompletionsRequest, Message, MessageContent, Role};
use hermesllm::transforms::lib::ExtractText;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use tracing::{debug, warn}; use tracing::{debug, warn};
@ -78,7 +79,9 @@ impl RouterModel for RouterModelV1 {
let messages_vec = messages let messages_vec = messages
.iter() .iter()
.filter(|m| { .filter(|m| {
m.role != Role::System && m.role != Role::Tool && !m.content.to_string().is_empty() m.role != Role::System
&& m.role != Role::Tool
&& !m.content.extract_text().is_empty()
}) })
.collect::<Vec<&Message>>(); .collect::<Vec<&Message>>();
@ -87,7 +90,7 @@ impl RouterModel for RouterModelV1 {
let mut token_count = ARCH_ROUTER_V1_SYSTEM_PROMPT.len() / TOKEN_LENGTH_DIVISOR; let mut token_count = ARCH_ROUTER_V1_SYSTEM_PROMPT.len() / TOKEN_LENGTH_DIVISOR;
let mut selected_messages_list_reversed: Vec<&Message> = vec![]; let mut selected_messages_list_reversed: Vec<&Message> = vec![];
for (selected_messsage_count, message) in messages_vec.iter().rev().enumerate() { for (selected_messsage_count, message) in messages_vec.iter().rev().enumerate() {
let message_token_count = message.content.to_string().len() / TOKEN_LENGTH_DIVISOR; let message_token_count = message.content.extract_text().len() / TOKEN_LENGTH_DIVISOR;
token_count += message_token_count; token_count += message_token_count;
if token_count > self.max_token_length { if token_count > self.max_token_length {
debug!( debug!(
@ -136,7 +139,12 @@ impl RouterModel for RouterModelV1 {
Message { Message {
role: message.role.clone(), role: message.role.clone(),
// we can unwrap here because we have already filtered out messages without content // we can unwrap here because we have already filtered out messages without content
content: MessageContent::Text(message.content.to_string()), content: Some(MessageContent::Text(
message
.content
.as_ref()
.map_or(String::new(), |c| c.to_string()),
)),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -154,7 +162,7 @@ impl RouterModel for RouterModelV1 {
ChatCompletionsRequest { ChatCompletionsRequest {
model: self.routing_model.clone(), model: self.routing_model.clone(),
messages: vec![Message { messages: vec![Message {
content: MessageContent::Text(router_message), content: Some(MessageContent::Text(router_message)),
role: Role::User, role: Role::User,
name: None, name: None,
tool_calls: None, tool_calls: None,
@ -344,7 +352,7 @@ Based on your analysis, provide your response in the following JSON formats if y
let req = router.generate_request(&conversation, &None); let req = router.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -409,7 +417,7 @@ Based on your analysis, provide your response in the following JSON formats if y
}]); }]);
let req = router.generate_request(&conversation, &usage_preferences); let req = router.generate_request(&conversation, &usage_preferences);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -469,7 +477,7 @@ Based on your analysis, provide your response in the following JSON formats if y
let req = router.generate_request(&conversation, &None); let req = router.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -530,7 +538,7 @@ Based on your analysis, provide your response in the following JSON formats if y
let req = router.generate_request(&conversation, &None); let req = router.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -598,7 +606,7 @@ Based on your analysis, provide your response in the following JSON formats if y
let req = router.generate_request(&conversation, &None); let req = router.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -667,7 +675,7 @@ Based on your analysis, provide your response in the following JSON formats if y
let req = router.generate_request(&conversation, &None); let req = router.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }
@ -762,7 +770,7 @@ Based on your analysis, provide your response in the following JSON formats if y
let req: ChatCompletionsRequest = router.generate_request(&conversation, &None); let req: ChatCompletionsRequest = router.generate_request(&conversation, &None);
let prompt = req.messages[0].content.to_string(); let prompt = req.messages[0].content.extract_text();
assert_eq!(expected_prompt, prompt); assert_eq!(expected_prompt, prompt);
} }

17
crates/brightstaff/src/signals/analyzer.rs
View file

@ -1122,9 +1122,9 @@ pub struct TextBasedSignalAnalyzer {
impl TextBasedSignalAnalyzer { impl TextBasedSignalAnalyzer {
/// Extract text content from MessageContent, skipping non-text content /// Extract text content from MessageContent, skipping non-text content
fn extract_text(content: &hermesllm::apis::openai::MessageContent) -> Option<String> { fn extract_text(content: &Option<hermesllm::apis::openai::MessageContent>) -> Option<String> {
match content { match content {
hermesllm::apis::openai::MessageContent::Text(text) => Some(text.clone()), Some(hermesllm::apis::openai::MessageContent::Text(text)) => Some(text.clone()),
// Tool calls and other structured content are skipped // Tool calls and other structured content are skipped
_ => None, _ => None,
} }
@ -1941,12 +1941,13 @@ impl Default for TextBasedSignalAnalyzer {
mod tests { mod tests {
use super::*; use super::*;
use hermesllm::apis::openai::MessageContent; use hermesllm::apis::openai::MessageContent;
use hermesllm::transforms::lib::ExtractText;
use std::time::Instant; use std::time::Instant;
fn create_message(role: Role, content: &str) -> Message { fn create_message(role: Role, content: &str) -> Message {
Message { Message {
role, role,
content: MessageContent::Text(content.to_string()), content: Some(MessageContent::Text(content.to_string())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -2130,7 +2131,7 @@ mod tests {
.iter() .iter()
.enumerate() .enumerate()
.map(|(i, msg)| { .map(|(i, msg)| {
let text = msg.content.to_string(); let text = msg.content.extract_text();
(i, msg.role.clone(), NormalizedMessage::from_text(&text)) (i, msg.role.clone(), NormalizedMessage::from_text(&text))
}) })
.collect() .collect()
@ -2532,7 +2533,7 @@ mod tests {
|content: &str, tool_id: &str, tool_name: &str, args: &str| -> Message { |content: &str, tool_id: &str, tool_name: &str, args: &str| -> Message {
Message { Message {
role: Role::Assistant, role: Role::Assistant,
content: MessageContent::Text(content.to_string()), content: Some(MessageContent::Text(content.to_string())),
name: None, name: None,
tool_calls: Some(vec![ToolCall { tool_calls: Some(vec![ToolCall {
id: tool_id.to_string(), id: tool_id.to_string(),
@ -2550,7 +2551,7 @@ mod tests {
let create_tool_message = |tool_call_id: &str, content: &str| -> Message { let create_tool_message = |tool_call_id: &str, content: &str| -> Message {
Message { Message {
role: Role::Tool, role: Role::Tool,
content: MessageContent::Text(content.to_string()), content: Some(MessageContent::Text(content.to_string())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: Some(tool_call_id.to_string()), tool_call_id: Some(tool_call_id.to_string()),
@ -2665,7 +2666,7 @@ mod tests {
|content: &str, tool_id: &str, tool_name: &str, args: &str| -> Message { |content: &str, tool_id: &str, tool_name: &str, args: &str| -> Message {
Message { Message {
role: Role::Assistant, role: Role::Assistant,
content: MessageContent::Text(content.to_string()), content: Some(MessageContent::Text(content.to_string())),
name: None, name: None,
tool_calls: Some(vec![ToolCall { tool_calls: Some(vec![ToolCall {
id: tool_id.to_string(), id: tool_id.to_string(),
@ -2683,7 +2684,7 @@ mod tests {
let create_tool_message = |tool_call_id: &str, content: &str| -> Message { let create_tool_message = |tool_call_id: &str, content: &str| -> Message {
Message { Message {
role: Role::Tool, role: Role::Tool,
content: MessageContent::Text(content.to_string()), content: Some(MessageContent::Text(content.to_string())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: Some(tool_call_id.to_string()), tool_call_id: Some(tool_call_id.to_string()),

19
crates/hermesllm/src/apis/amazon_bedrock.rs
View file

@ -225,7 +225,7 @@ impl ProviderRequest for ConverseRequest {
if let SystemContentBlock::Text { text } = sys_block { if let SystemContentBlock::Text { text } = sys_block {
openai_messages.push(Message { openai_messages.push(Message {
role: Role::System, role: Role::System,
content: MessageContent::Text(text.clone()), content: Some(MessageContent::Text(text.clone())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -258,7 +258,7 @@ impl ProviderRequest for ConverseRequest {
openai_messages.push(Message { openai_messages.push(Message {
role, role,
content: MessageContent::Text(content), content: Some(MessageContent::Text(content)),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -279,7 +279,7 @@ impl ProviderRequest for ConverseRequest {
for msg in messages { for msg in messages {
match msg.role { match msg.role {
crate::apis::openai::Role::System => { crate::apis::openai::Role::System => {
if let crate::apis::openai::MessageContent::Text(text) = &msg.content { if let Some(crate::apis::openai::MessageContent::Text(text)) = &msg.content {
system_blocks.push(SystemContentBlock::Text { text: text.clone() }); system_blocks.push(SystemContentBlock::Text { text: text.clone() });
} }
} }
@ -290,12 +290,13 @@ impl ProviderRequest for ConverseRequest {
_ => continue, _ => continue,
}; };
let content = let content = if let Some(crate::apis::openai::MessageContent::Text(text)) =
if let crate::apis::openai::MessageContent::Text(text) = &msg.content { &msg.content
vec![ContentBlock::Text { text: text.clone() }] {
} else { vec![ContentBlock::Text { text: text.clone() }]
vec![] } else {
}; vec![]
};
bedrock_messages.push(crate::apis::amazon_bedrock::Message { role, content }); bedrock_messages.push(crate::apis::amazon_bedrock::Message { role, content });
} }

2
crates/hermesllm/src/apis/anthropic.rs
View file

@ -584,7 +584,7 @@ impl ProviderRequest for MessagesRequest {
let system_text = system_messages let system_text = system_messages
.iter() .iter()
.filter_map(|msg| { .filter_map(|msg| {
if let crate::apis::openai::MessageContent::Text(text) = &msg.content { if let Some(crate::apis::openai::MessageContent::Text(text)) = &msg.content {
Some(text.as_str()) Some(text.as_str())
} else { } else {
None None

123
crates/hermesllm/src/apis/openai.rs
View file

@ -155,7 +155,8 @@ pub enum Role {
#[derive(Serialize, Deserialize, Debug, Clone)] #[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Message { pub struct Message {
pub role: Role, pub role: Role,
pub content: MessageContent, /// The contents of the message. Required unless tool_calls is specified (for assistant role)
pub content: Option<MessageContent>,
pub name: Option<String>, pub name: Option<String>,
/// Tool calls made by the assistant (only present for assistant role) /// Tool calls made by the assistant (only present for assistant role)
pub tool_calls: Option<Vec<ToolCall>>, pub tool_calls: Option<Vec<ToolCall>>,
@ -204,8 +205,7 @@ impl ResponseMessage {
content: self content: self
.content .content
.as_ref() .as_ref()
.map(|s| MessageContent::Text(s.clone())) .map(|s| MessageContent::Text(s.clone())),
.unwrap_or(MessageContent::Text(String::new())),
name: None, // Response messages don't have names in the same way request messages do name: None, // Response messages don't have names in the same way request messages do
tool_calls: self.tool_calls.clone(), tool_calls: self.tool_calls.clone(),
tool_call_id: None, // Response messages don't have tool_call_id tool_call_id: None, // Response messages don't have tool_call_id
@ -233,6 +233,12 @@ impl ExtractText for MessageContent {
} }
} }
impl ExtractText for Option<MessageContent> {
fn extract_text(&self) -> String {
self.as_ref().map(|c| c.extract_text()).unwrap_or_default()
}
}
impl ExtractText for Vec<ContentPart> { impl ExtractText for Vec<ContentPart> {
fn extract_text(&self) -> String { fn extract_text(&self) -> String {
self.iter() self.iter()
@ -247,23 +253,7 @@ impl ExtractText for Vec<ContentPart> {
impl Display for MessageContent { impl Display for MessageContent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self { write!(f, "{}", self.extract_text())
MessageContent::Text(text) => write!(f, "{}", text),
MessageContent::Parts(parts) => {
let text_parts: Vec<String> = parts
.iter()
.filter_map(|part| match part {
ContentPart::Text { text } => Some(text.clone()),
ContentPart::ImageUrl { .. } => {
// skip image URLs or their data in text representation
None
}
})
.collect();
let combined_text = text_parts.join("\n");
write!(f, "{}", combined_text)
}
}
} }
} }
@ -622,8 +612,10 @@ impl ProviderRequest for ChatCompletionsRequest {
fn extract_messages_text(&self) -> String { fn extract_messages_text(&self) -> String {
self.messages.iter().fold(String::new(), |acc, m| { self.messages.iter().fold(String::new(), |acc, m| {
acc + " " let content_text = m
+ &match &m.content { .content
.as_ref()
.map(|content| match content {
MessageContent::Text(text) => text.clone(), MessageContent::Text(text) => text.clone(),
MessageContent::Parts(parts) => parts MessageContent::Parts(parts) => parts
.iter() .iter()
@ -633,16 +625,18 @@ impl ProviderRequest for ChatCompletionsRequest {
}) })
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(" "), .join(" "),
} })
.unwrap_or_default();
acc + " " + &content_text
}) })
} }
fn get_recent_user_message(&self) -> Option<String> { fn get_recent_user_message(&self) -> Option<String> {
self.messages.last().and_then(|msg| { self.messages.last().and_then(|msg| {
match &msg.content { msg.content.as_ref().and_then(|content| match content {
MessageContent::Text(text) => Some(text.clone()), MessageContent::Text(text) => Some(text.clone()),
MessageContent::Parts(_) => None, // No user message in parts MessageContent::Parts(_) => None, // No user message in parts
} })
}) })
} }
@ -778,7 +772,8 @@ mod tests {
let message = &deserialized_request.messages[0]; let message = &deserialized_request.messages[0];
assert_eq!(message.role, Role::User); assert_eq!(message.role, Role::User);
if let MessageContent::Text(content) = &message.content { assert!(message.content.is_some());
if let Some(MessageContent::Text(content)) = &message.content {
assert_eq!(content, "Hello, world!"); assert_eq!(content, "Hello, world!");
} else { } else {
panic!("Expected text content"); panic!("Expected text content");
@ -822,7 +817,8 @@ mod tests {
let message = &deserialized_request.messages[0]; let message = &deserialized_request.messages[0];
assert_eq!(message.role, Role::User); assert_eq!(message.role, Role::User);
if let MessageContent::Text(content) = &message.content { assert!(message.content.is_some());
if let Some(MessageContent::Text(content)) = &message.content {
assert_eq!(content, "Test message"); assert_eq!(content, "Test message");
} else { } else {
panic!("Expected text content"); panic!("Expected text content");
@ -947,7 +943,8 @@ mod tests {
// Validate first message (user with multimodal content) // Validate first message (user with multimodal content)
let user_message = &deserialized_request.messages[0]; let user_message = &deserialized_request.messages[0];
assert_eq!(user_message.role, Role::User); assert_eq!(user_message.role, Role::User);
if let MessageContent::Parts(ref content_parts) = user_message.content { assert!(user_message.content.is_some());
if let Some(MessageContent::Parts(ref content_parts)) = user_message.content {
assert_eq!(content_parts.len(), 2); assert_eq!(content_parts.len(), 2);
// Validate text content part // Validate text content part
@ -971,7 +968,8 @@ mod tests {
// Validate second message (assistant with tool calls) // Validate second message (assistant with tool calls)
let assistant_message = &deserialized_request.messages[1]; let assistant_message = &deserialized_request.messages[1];
assert_eq!(assistant_message.role, Role::Assistant); assert_eq!(assistant_message.role, Role::Assistant);
if let MessageContent::Text(text) = &assistant_message.content { assert!(assistant_message.content.is_some());
if let Some(MessageContent::Text(text)) = &assistant_message.content {
assert_eq!( assert_eq!(
text, text,
"I can see a beautiful cityscape. Let me check the weather for you." "I can see a beautiful cityscape. Let me check the weather for you."
@ -997,7 +995,8 @@ mod tests {
// Validate third message (tool response) // Validate third message (tool response)
let tool_message = &deserialized_request.messages[2]; let tool_message = &deserialized_request.messages[2];
assert_eq!(tool_message.role, Role::Tool); assert_eq!(tool_message.role, Role::Tool);
if let MessageContent::Text(text) = &tool_message.content { assert!(tool_message.content.is_some());
if let Some(MessageContent::Text(text)) = &tool_message.content {
assert_eq!(text, "Current weather in New York: 72°F, sunny"); assert_eq!(text, "Current weather in New York: 72°F, sunny");
} else { } else {
panic!("Expected text content for tool message"); panic!("Expected text content for tool message");
@ -1061,6 +1060,62 @@ mod tests {
assert!((original_temp - serialized_temp).abs() < 1e-6); assert!((original_temp - serialized_temp).abs() < 1e-6);
} }
#[test]
fn test_assistant_message_with_tool_calls_no_content() {
// Test that assistant messages can have tool_calls without content
let json_with_tool_calls_no_content = json!({
"model": "gpt-4",
"messages": [
{
"role": "user",
"content": "What's the weather in San Francisco?"
},
{
"role": "assistant",
"tool_calls": [
{
"id": "call_123",
"type": "function",
"function": {
"name": "get_weather",
"arguments": "{\"location\": \"San Francisco, CA\"}"
}
}
]
}
]
});
// Should deserialize successfully
let request: ChatCompletionsRequest =
serde_json::from_value(json_with_tool_calls_no_content.clone()).unwrap();
assert_eq!(request.messages.len(), 2);
// Check user message
let user_msg = &request.messages[0];
assert_eq!(user_msg.role, Role::User);
assert!(user_msg.content.is_some());
// Check assistant message - should have tool_calls but no content
let assistant_msg = &request.messages[1];
assert_eq!(assistant_msg.role, Role::Assistant);
assert!(assistant_msg.content.is_none());
assert!(assistant_msg.tool_calls.is_some());
let tool_calls = assistant_msg.tool_calls.as_ref().unwrap();
assert_eq!(tool_calls.len(), 1);
assert_eq!(tool_calls[0].id, "call_123");
assert_eq!(tool_calls[0].function.name, "get_weather");
// Should serialize back without content field
let serialized = serde_json::to_value(&request).unwrap();
// Verify the assistant message doesn't have a content field in serialized JSON
let serialized_assistant_msg = &serialized["messages"][1];
assert!(serialized_assistant_msg.get("content").is_none());
assert!(serialized_assistant_msg.get("tool_calls").is_some());
}
#[test] #[test]
fn test_api_provider_trait() { fn test_api_provider_trait() {
// Test the ApiDefinition trait implementation // Test the ApiDefinition trait implementation
@ -1097,7 +1152,7 @@ mod tests {
let deserialized_user: Message = serde_json::from_value(user_json.clone()).unwrap(); let deserialized_user: Message = serde_json::from_value(user_json.clone()).unwrap();
assert_eq!(deserialized_user.role, Role::User); assert_eq!(deserialized_user.role, Role::User);
if let MessageContent::Text(content) = &deserialized_user.content { if let Some(MessageContent::Text(content)) = &deserialized_user.content {
assert_eq!(content, "Hello!"); assert_eq!(content, "Hello!");
} else { } else {
panic!("Expected text content"); panic!("Expected text content");
@ -1128,7 +1183,7 @@ mod tests {
let deserialized_assistant: Message = let deserialized_assistant: Message =
serde_json::from_value(assistant_json.clone()).unwrap(); serde_json::from_value(assistant_json.clone()).unwrap();
assert_eq!(deserialized_assistant.role, Role::Assistant); assert_eq!(deserialized_assistant.role, Role::Assistant);
if let MessageContent::Text(content) = &deserialized_assistant.content { if let Some(MessageContent::Text(content)) = &deserialized_assistant.content {
assert_eq!(content, "I'll help with that."); assert_eq!(content, "I'll help with that.");
} else { } else {
panic!("Expected text content"); panic!("Expected text content");
@ -1154,7 +1209,7 @@ mod tests {
let deserialized_tool: Message = serde_json::from_value(tool_json.clone()).unwrap(); let deserialized_tool: Message = serde_json::from_value(tool_json.clone()).unwrap();
assert_eq!(deserialized_tool.role, Role::Tool); assert_eq!(deserialized_tool.role, Role::Tool);
if let MessageContent::Text(content) = &deserialized_tool.content { if let Some(MessageContent::Text(content)) = &deserialized_tool.content {
assert_eq!(content, "Weather is sunny"); assert_eq!(content, "Weather is sunny");
} else { } else {
panic!("Expected text content"); panic!("Expected text content");
@ -1193,7 +1248,7 @@ mod tests {
// Test conversion from ResponseMessage to Message // Test conversion from ResponseMessage to Message
let converted = deserialized_response.to_message(); let converted = deserialized_response.to_message();
assert_eq!(converted.role, Role::Assistant); assert_eq!(converted.role, Role::Assistant);
if let MessageContent::Text(text) = converted.content { if let Some(MessageContent::Text(text)) = converted.content {
assert_eq!(text, "Response content"); assert_eq!(text, "Response content");
} else { } else {
panic!("Expected text content"); panic!("Expected text content");

8
crates/hermesllm/src/apis/openai_responses.rs
View file

@ -1146,7 +1146,7 @@ impl ProviderRequest for ResponsesAPIRequest {
.iter() .iter()
.filter(|msg| msg.role == crate::apis::openai::Role::System) .filter(|msg| msg.role == crate::apis::openai::Role::System)
.filter_map(|msg| { .filter_map(|msg| {
if let crate::apis::openai::MessageContent::Text(text) = &msg.content { if let Some(crate::apis::openai::MessageContent::Text(text)) = &msg.content {
Some(text.as_str()) Some(text.as_str())
} else { } else {
None None
@ -1170,7 +1170,8 @@ impl ProviderRequest for ResponsesAPIRequest {
if !input_messages.is_empty() { if !input_messages.is_empty() {
// If there's only one message, use Text format // If there's only one message, use Text format
if input_messages.len() == 1 { if input_messages.len() == 1 {
if let crate::apis::openai::MessageContent::Text(text) = &input_messages[0].content if let Some(crate::apis::openai::MessageContent::Text(text)) =
&input_messages[0].content
{ {
self.input = crate::apis::openai_responses::InputParam::Text(text.clone()); self.input = crate::apis::openai_responses::InputParam::Text(text.clone());
} }
@ -1180,7 +1181,8 @@ impl ProviderRequest for ResponsesAPIRequest {
let combined_text = input_messages let combined_text = input_messages
.iter() .iter()
.filter_map(|msg| { .filter_map(|msg| {
if let crate::apis::openai::MessageContent::Text(text) = &msg.content { if let Some(crate::apis::openai::MessageContent::Text(text)) = &msg.content
{
Some(format!( Some(format!(
"{}: {}", "{}: {}",
match msg.role { match msg.role {

12
crates/hermesllm/src/providers/request.rs
View file

@ -671,14 +671,16 @@ mod tests {
messages: vec![ messages: vec![
Message { Message {
role: Role::System, role: Role::System,
content: MessageContent::Text("You are a helpful assistant".to_string()), content: Some(MessageContent::Text(
"You are a helpful assistant".to_string(),
)),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
}, },
Message { Message {
role: Role::User, role: Role::User,
content: MessageContent::Text("Hello!".to_string()), content: Some(MessageContent::Text("Hello!".to_string())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -900,7 +902,7 @@ mod tests {
model: "gpt-4".to_string(), model: "gpt-4".to_string(),
messages: vec![Message { messages: vec![Message {
role: Role::User, role: Role::User,
content: MessageContent::Text("Hello!".to_string()), content: Some(MessageContent::Text("Hello!".to_string())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -993,14 +995,14 @@ mod tests {
messages: vec![ messages: vec![
Message { Message {
role: Role::System, role: Role::System,
content: MessageContent::Text("You are helpful".to_string()), content: Some(MessageContent::Text("You are helpful".to_string())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
}, },
Message { Message {
role: Role::User, role: Role::User,
content: MessageContent::Text("Hello!".to_string()), content: Some(MessageContent::Text("Hello!".to_string())),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,

5
crates/hermesllm/src/transforms/lib.rs
View file

@ -188,7 +188,7 @@ pub fn convert_openai_message_to_anthropic_content(
// Handle regular content // Handle regular content
match &message.content { match &message.content {
MessageContent::Text(text) => { Some(MessageContent::Text(text)) => {
if !text.is_empty() { if !text.is_empty() {
blocks.push(MessagesContentBlock::Text { blocks.push(MessagesContentBlock::Text {
text: text.clone(), text: text.clone(),
@ -196,7 +196,7 @@ pub fn convert_openai_message_to_anthropic_content(
}); });
} }
} }
MessageContent::Parts(parts) => { Some(MessageContent::Parts(parts)) => {
for part in parts { for part in parts {
match part { match part {
ContentPart::Text { text } => { ContentPart::Text { text } => {
@ -212,6 +212,7 @@ pub fn convert_openai_message_to_anthropic_content(
} }
} }
} }
None => {}
} }
// Handle tool calls // Handle tool calls

21
crates/hermesllm/src/transforms/request/from_anthropic.rs
View file

@ -174,7 +174,7 @@ impl TryFrom<MessagesMessage> for Vec<Message> {
MessagesMessageContent::Single(text) => { MessagesMessageContent::Single(text) => {
result.push(Message { result.push(Message {
role: message.role.into(), role: message.role.into(),
content: MessageContent::Text(text), content: Some(MessageContent::Text(text)),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -186,7 +186,7 @@ impl TryFrom<MessagesMessage> for Vec<Message> {
for (tool_use_id, result_text, _is_error) in tool_results { for (tool_use_id, result_text, _is_error) in tool_results {
result.push(Message { result.push(Message {
role: Role::Tool, role: Role::Tool,
content: MessageContent::Text(result_text), content: Some(MessageContent::Text(result_text)),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: Some(tool_use_id), tool_call_id: Some(tool_use_id),
@ -260,7 +260,7 @@ impl From<MessagesSystemPrompt> for Message {
Message { Message {
role: Role::System, role: Role::System,
content: system_content, content: Some(system_content),
name: None, name: None,
tool_calls: None, tool_calls: None,
tool_call_id: None, tool_call_id: None,
@ -317,16 +317,19 @@ fn convert_anthropic_tool_choice(
fn build_openai_content( fn build_openai_content(
content_parts: Vec<ContentPart>, content_parts: Vec<ContentPart>,
tool_calls: &[ToolCall], tool_calls: &[ToolCall],
) -> MessageContent { ) -> Option<MessageContent> {
if content_parts.len() == 1 && tool_calls.is_empty() { if content_parts.is_empty() && !tool_calls.is_empty() {
// For assistant messages with only tool calls, content is optional
None
} else if content_parts.len() == 1 && tool_calls.is_empty() {
match &content_parts[0] { match &content_parts[0] {
ContentPart::Text { text } => MessageContent::Text(text.clone()), ContentPart::Text { text } => Some(MessageContent::Text(text.clone())),
_ => MessageContent::Parts(content_parts), _ => Some(MessageContent::Parts(content_parts)),
} }
} else if content_parts.is_empty() { } else if content_parts.is_empty() {
MessageContent::Text("".to_string()) Some(MessageContent::Text("".to_string()))
} else { } else {
MessageContent::Parts(content_parts) Some(MessageContent::Parts(content_parts))
} }
} }

53
crates/hermesllm/src/transforms/request/from_openai.rs
View file

@ -18,7 +18,6 @@ use crate::apis::openai_responses::{
ResponsesAPIRequest, Tool as ResponsesTool, ToolChoice as ResponsesToolChoice, ResponsesAPIRequest, Tool as ResponsesTool, ToolChoice as ResponsesToolChoice,
}; };
use crate::clients::TransformError; use crate::clients::TransformError;
use crate::transforms::lib::ExtractText;
use crate::transforms::lib::*; use crate::transforms::lib::*;
use crate::transforms::*; use crate::transforms::*;
@ -48,7 +47,7 @@ impl TryFrom<ResponsesInputConverter> for Vec<Message> {
if let Some(instructions) = converter.instructions { if let Some(instructions) = converter.instructions {
messages.push(Message { messages.push(Message {
role: Role::System, role: Role::System,
content: MessageContent::Text(instructions), content: Some(MessageContent::Text(instructions)),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
@ -58,7 +57,7 @@ impl TryFrom<ResponsesInputConverter> for Vec<Message> {
// Add the user message // Add the user message
messages.push(Message { messages.push(Message {
role: Role::User, role: Role::User,
content: MessageContent::Text(text), content: Some(MessageContent::Text(text)),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
@ -74,7 +73,7 @@ impl TryFrom<ResponsesInputConverter> for Vec<Message> {
if let Some(instructions) = converter.instructions { if let Some(instructions) = converter.instructions {
converted_messages.push(Message { converted_messages.push(Message {
role: Role::System, role: Role::System,
content: MessageContent::Text(instructions), content: Some(MessageContent::Text(instructions)),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
@ -154,7 +153,7 @@ impl TryFrom<ResponsesInputConverter> for Vec<Message> {
converted_messages.push(Message { converted_messages.push(Message {
role, role,
content, content: Some(content),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
@ -174,11 +173,7 @@ impl TryFrom<ResponsesInputConverter> for Vec<Message> {
impl From<Message> for MessagesSystemPrompt { impl From<Message> for MessagesSystemPrompt {
fn from(val: Message) -> Self { fn from(val: Message) -> Self {
let system_text = match val.content { MessagesSystemPrompt::Single(val.content.extract_text())
MessageContent::Text(text) => text,
MessageContent::Parts(parts) => parts.extract_text(),
};
MessagesSystemPrompt::Single(system_text)
} }
} }
@ -191,6 +186,8 @@ impl TryFrom<Message> for MessagesMessage {
Role::Assistant => MessagesRole::Assistant, Role::Assistant => MessagesRole::Assistant,
Role::Tool => { Role::Tool => {
// Tool messages become user messages with tool results // Tool messages become user messages with tool results
// Extract content text first, before moving tool_call_id
let content_text = message.content.extract_text();
let tool_call_id = message.tool_call_id.ok_or_else(|| { let tool_call_id = message.tool_call_id.ok_or_else(|| {
TransformError::MissingField( TransformError::MissingField(
"tool_call_id required for Tool messages".to_string(), "tool_call_id required for Tool messages".to_string(),
@ -204,7 +201,7 @@ impl TryFrom<Message> for MessagesMessage {
tool_use_id: tool_call_id, tool_use_id: tool_call_id,
is_error: None, is_error: None,
content: ToolResultContent::Blocks(vec![MessagesContentBlock::Text { content: ToolResultContent::Blocks(vec![MessagesContentBlock::Text {
text: message.content.extract_text(), text: content_text,
cache_control: None, cache_control: None,
}]), }]),
cache_control: None, cache_control: None,
@ -248,12 +245,12 @@ impl TryFrom<Message> for BedrockMessage {
Role::User => { Role::User => {
// Convert user message content to content blocks // Convert user message content to content blocks
match message.content { match message.content {
MessageContent::Text(text) => { Some(MessageContent::Text(text)) => {
if !text.is_empty() { if !text.is_empty() {
content_blocks.push(ContentBlock::Text { text }); content_blocks.push(ContentBlock::Text { text });
} }
} }
MessageContent::Parts(parts) => { Some(MessageContent::Parts(parts)) => {
// Convert OpenAI content parts to Bedrock ContentBlocks // Convert OpenAI content parts to Bedrock ContentBlocks
for part in parts { for part in parts {
match part { match part {
@ -293,6 +290,9 @@ impl TryFrom<Message> for BedrockMessage {
} }
} }
} }
None => {
// Empty content for user - shouldn't happen but handle gracefully
}
} }
// Ensure we have at least one content block // Ensure we have at least one content block
@ -550,10 +550,7 @@ impl TryFrom<ChatCompletionsRequest> for ConverseRequest {
for message in req.messages { for message in req.messages {
match message.role { match message.role {
Role::System => { Role::System => {
let system_text = match message.content { let system_text = message.content.extract_text();
MessageContent::Text(text) => text,
MessageContent::Parts(parts) => parts.extract_text(),
};
system_messages.push(SystemContentBlock::Text { text: system_text }); system_messages.push(SystemContentBlock::Text { text: system_text });
} }
_ => { _ => {
@ -778,14 +775,16 @@ mod tests {
messages: vec![ messages: vec![
Message { Message {
role: Role::System, role: Role::System,
content: MessageContent::Text("You are a helpful assistant.".to_string()), content: Some(MessageContent::Text(
"You are a helpful assistant.".to_string(),
)),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
}, },
Message { Message {
role: Role::User, role: Role::User,
content: MessageContent::Text("Hello, how are you?".to_string()), content: Some(MessageContent::Text("Hello, how are you?".to_string())),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
@ -840,7 +839,7 @@ mod tests {
model: "gpt-4".to_string(), model: "gpt-4".to_string(),
messages: vec![Message { messages: vec![Message {
role: Role::User, role: Role::User,
content: MessageContent::Text("What's the weather like?".to_string()), content: Some(MessageContent::Text("What's the weather like?".to_string())),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
@ -907,7 +906,7 @@ mod tests {
model: "gpt-4".to_string(), model: "gpt-4".to_string(),
messages: vec![Message { messages: vec![Message {
role: Role::User, role: Role::User,
content: MessageContent::Text("Help me with something".to_string()), content: Some(MessageContent::Text("Help me with something".to_string())),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
@ -950,28 +949,30 @@ mod tests {
messages: vec![ messages: vec![
Message { Message {
role: Role::System, role: Role::System,
content: MessageContent::Text("Be concise".to_string()), content: Some(MessageContent::Text("Be concise".to_string())),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
}, },
Message { Message {
role: Role::User, role: Role::User,
content: MessageContent::Text("Hello".to_string()), content: Some(MessageContent::Text("Hello".to_string())),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
}, },
Message { Message {
role: Role::Assistant, role: Role::Assistant,
content: MessageContent::Text("Hi there! How can I help you?".to_string()), content: Some(MessageContent::Text(
"Hi there! How can I help you?".to_string(),
)),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
}, },
Message { Message {
role: Role::User, role: Role::User,
content: MessageContent::Text("What's 2+2?".to_string()), content: Some(MessageContent::Text("What's 2+2?".to_string())),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,
@ -1009,7 +1010,7 @@ mod tests {
fn test_openai_message_to_bedrock_conversion() { fn test_openai_message_to_bedrock_conversion() {
let openai_message = Message { let openai_message = Message {
role: Role::User, role: Role::User,
content: MessageContent::Text("Test message".to_string()), content: Some(MessageContent::Text("Test message".to_string())),
name: None, name: None,
tool_call_id: None, tool_call_id: None,
tool_calls: None, tool_calls: None,

75
tests/e2e/test_model_alias_routing.py
View file

@ -22,6 +22,81 @@ LLM_GATEWAY_ENDPOINT = os.getenv(
# ============================================================================= # =============================================================================
def test_assistant_message_with_null_content_and_tool_calls():
"""Test that assistant messages with null content and tool_calls are properly handled"""
logger.info(
"Testing assistant message with null content and tool_calls (multi-turn conversation)"
)
base_url = LLM_GATEWAY_ENDPOINT.replace("/v1/chat/completions", "")
client = openai.OpenAI(
api_key="test-key",
base_url=f"{base_url}/v1",
)
# Simulate a multi-turn conversation where:
# 1. User asks a question
# 2. Assistant makes a tool call (with null content)
# 3. Tool responds
# 4. Assistant should provide final answer
completion = client.chat.completions.create(
model="gpt-4o",
max_tokens=500,
messages=[
{
"role": "system",
"content": "You are a weather assistant. Use the get_weather tool to fetch weather information.",
},
{"role": "user", "content": "What's the weather in Seattle?"},
{
"role": "assistant",
"content": None, # This is the key test - null content with tool_calls
"tool_calls": [
{
"id": "call_test123",
"type": "function",
"function": {
"name": "get_weather",
"arguments": '{"city": "Seattle"}',
},
}
],
},
{
"role": "tool",
"tool_call_id": "call_test123",
"content": '{"location": "Seattle", "temperature": "10°C", "condition": "Partly cloudy"}',
},
],
tools=[
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get weather information for a city",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "City name"}
},
"required": ["city"],
},
},
}
],
)
response_content = completion.choices[0].message.content
logger.info(f"Response after tool call: {response_content}")
# The assistant should provide a final response using the tool result
assert response_content is not None
assert len(response_content) > 0
logger.info(
"✓ Assistant message with null content and tool_calls handled correctly"
)
def test_openai_client_with_alias_arch_summarize_v1(): def test_openai_client_with_alias_arch_summarize_v1():
"""Test OpenAI client using model alias 'arch.summarize.v1' which should resolve to '4o-mini'""" """Test OpenAI client using model alias 'arch.summarize.v1' which should resolve to '4o-mini'"""
logger.info("Testing OpenAI client with alias 'arch.summarize.v1' -> '4o-mini'") logger.info("Testing OpenAI client with alias 'arch.summarize.v1' -> '4o-mini'")