use ramvamp_core::tokenizer::{ChatMessage, Role, RvmpTokenizer, ToolArguments, ToolCall};
use crate::error::ServerError;
use crate::request::{ChatCompletionRequest, Message, MessageRole};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Prompt {
pub token_ids: Vec<u32>,
pub messages: Vec<ChatMessage>,
}
impl Prompt {
pub fn len(&self) -> usize {
self.token_ids.len()
}
pub fn is_empty(&self) -> bool {
self.token_ids.is_empty()
}
}
fn role_of(message: &Message) -> Role {
match message.role {
MessageRole::System => Role::System,
MessageRole::User => Role::User,
MessageRole::Assistant => Role::Assistant,
MessageRole::Tool => Role::Tool,
}
}
fn tool_call_of(call: &crate::request::ToolCall) -> ToolCall {
ToolCall {
name: call.function.name.clone(),
arguments: ToolArguments::Raw(call.function.arguments.clone()),
}
}
pub fn chat_messages(messages: &[Message]) -> Result<Vec<ChatMessage>, ServerError> {
let mut out = Vec::with_capacity(messages.len());
for message in messages {
message.check_tool_calls()?;
out.push(ChatMessage {
role: role_of(message),
content: message.text()?,
tool_calls: message.calls().iter().map(tool_call_of).collect(),
});
}
Ok(out)
}
pub fn build(
tokenizer: &RvmpTokenizer,
request: &ChatCompletionRequest,
) -> Result<Prompt, ServerError> {
if request.messages.is_empty() {
return Err(ServerError::EmptyMessages);
}
request.check_tools()?;
let messages = chat_messages(&request.messages)?;
let token_ids = tokenizer.encode_chat_with_tools_sanitized(&messages, request.tools(), true)?;
Ok(Prompt {
token_ids,
messages,
})
}
pub fn check_context(
prompt_tokens: usize,
max_new: usize,
limit: usize,
) -> Result<usize, ServerError> {
let requested = prompt_tokens.saturating_add(max_new);
if requested > limit {
return Err(ServerError::ContextOverflow { requested, limit });
}
Ok(limit - requested)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::request::{Content, ContentPart, FunctionCall, ToolCall};
use ramvamp_core::tokenizer::ToolCall as CoreToolCall;
fn message(role: MessageRole, content: &str) -> Message {
Message::new(role, content)
}
#[test]
fn roles_map_onto_the_renderer() {
let mapped = chat_messages(&[
message(MessageRole::System, "be terse"),
message(MessageRole::User, "hi"),
message(MessageRole::Assistant, "hello"),
])
.expect("supported roles");
assert_eq!(
mapped,
vec![
ChatMessage::system("be terse"),
ChatMessage::user("hi"),
ChatMessage::assistant("hello"),
]
);
}
#[test]
fn array_form_content_survives_the_mapping() {
let mut message = message(MessageRole::User, "");
message.content = Some(Content::Parts(vec![
ContentPart::text("what is "),
ContentPart::text("2+2?"),
]));
let mapped = chat_messages(&[message]).expect("text parts");
assert_eq!(mapped, vec![ChatMessage::user("what is 2+2?")]);
}
#[test]
fn a_non_text_part_stops_the_mapping() {
let mut message = message(MessageRole::User, "");
message.content = Some(Content::Parts(vec![ContentPart {
kind: "input_audio".to_owned(),
text: None,
}]));
assert!(matches!(
chat_messages(&[message]).expect_err("refused"),
ServerError::UnsupportedContentPart { .. }
));
}
#[test]
fn a_tool_message_maps_onto_the_tool_role() {
let mut tool = message(MessageRole::Tool, "31C");
tool.tool_call_id = Some("call_abc".to_owned());
assert_eq!(
chat_messages(&[tool]).expect("the renderer has a tool branch"),
vec![ChatMessage::tool("31C")]
);
}
#[test]
fn assistant_tool_calls_reach_the_renderer_with_their_arguments_verbatim() {
let arguments = r#"{ "city":"Cairo", "unit" : "C" }"#;
let mut assistant = message(MessageRole::Assistant, "");
assistant.tool_calls = Some(vec![ToolCall {
id: "call_abc".to_owned(),
kind: "function".to_owned(),
function: FunctionCall {
name: "get_weather".to_owned(),
arguments: arguments.to_owned(),
},
}]);
let mapped = chat_messages(&[assistant.clone()]).expect("calls are rendered");
assert_eq!(
mapped,
vec![ChatMessage::assistant_calling(
"",
vec![CoreToolCall::raw("get_weather", arguments)]
)]
);
assert!(matches!(
mapped[0].tool_calls[0].arguments,
ToolArguments::Raw(_)
));
assistant.tool_calls = Some(Vec::new());
let mapped = chat_messages(&[assistant]).expect("an empty list is not a tool call");
assert!(mapped[0].tool_calls.is_empty());
}
#[test]
fn a_hostile_call_name_stops_the_mapping() {
let mut assistant = message(MessageRole::Assistant, "");
assistant.tool_calls = Some(vec![ToolCall {
id: "call_abc".to_owned(),
kind: "function".to_owned(),
function: FunctionCall {
name: "get\"weather".to_owned(),
arguments: "{}".to_owned(),
},
}]);
assert!(matches!(
chat_messages(&[assistant]).expect_err("refused, not repaired"),
ServerError::InvalidToolName { .. }
));
}
#[test]
fn name_is_dropped_because_the_template_has_no_slot_for_it() {
let mut named = message(MessageRole::User, "hi");
named.name = Some("ada".to_owned());
assert_eq!(
chat_messages(&[named]).expect("valid"),
vec![ChatMessage::user("hi")]
);
}
fn fixture_tokenizer() -> RvmpTokenizer {
let fixtures =
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../core/src/tokenizer/fixtures");
RvmpTokenizer::load(&fixtures).expect("fixture tokenizer loads")
}
fn request(body: &str) -> ChatCompletionRequest {
let request = ChatCompletionRequest::from_json(body).expect("valid body");
request.validate().expect("valid request");
request
}
#[test]
fn tool_definitions_lengthen_the_prompt_they_are_sent_with() {
let tokenizer = fixture_tokenizer();
let messages = r#""model":"m","messages":[{"role":"user","content":"read main.rs"}]"#;
let bare = request(&format!("{{{messages}}}"));
let armed = request(&format!(
r#"{{{messages},"tools":[{{"type":"function","function":{{
"name":"read_file","description":"Read a file",
"parameters":{{"type":"object","properties":{{"path":{{"type":"string"}}}}}}
}}}}]}}"#
));
let bare = build(&tokenizer, &bare).expect("builds");
let armed = build(&tokenizer, &armed).expect("builds");
assert!(
armed.len() > bare.len(),
"tools must reach the model: {} with, {} without",
armed.len(),
bare.len()
);
let rendered = tokenizer.decode(&armed.token_ids, false).expect("decodes");
assert!(rendered.contains("# Tools"), "{rendered}");
assert!(rendered.contains("read_file"), "{rendered}");
}
#[test]
fn a_call_and_its_result_both_reach_the_prompt() {
let tokenizer = fixture_tokenizer();
let request = request(
r#"{"model":"m","messages":[
{"role":"user","content":"weather?"},
{"role":"assistant","content":null,"tool_calls":[
{"id":"call_abc","type":"function",
"function":{"name":"get_weather","arguments":"{\"city\": \"Cairo\"}"}}
]},
{"role":"tool","tool_call_id":"call_abc","content":"31C"}
]}"#,
);
let prompt = build(&tokenizer, &request).expect("builds");
let rendered = tokenizer.decode(&prompt.token_ids, false).expect("decodes");
assert!(rendered.contains("<tool_call>"), "{rendered}");
assert!(rendered.contains(r#"{"city": "Cairo"}"#), "{rendered}");
assert!(
rendered.contains("<tool_response>\n31C\n</tool_response>"),
"{rendered}"
);
}
#[test]
fn context_check_reports_the_room_left() {
assert_eq!(check_context(0, 0, 4096).ok(), Some(4096));
assert_eq!(check_context(100, 128, 4096).ok(), Some(4096 - 228));
assert_eq!(check_context(4096 - 128, 128, 4096).ok(), Some(0));
}
#[test]
fn context_check_refuses_an_overrun_and_names_both_numbers() {
let error = check_context(4000, 128, 4096).expect_err("does not fit");
assert!(matches!(
error,
ServerError::ContextOverflow {
requested: 4128,
limit: 4096
}
));
assert_eq!(error.status(), 400);
let message = error.to_string();
assert!(
message.contains("4128") && message.contains("4096"),
"{message}"
);
}
#[test]
fn context_check_does_not_wrap() {
assert!(matches!(
check_context(usize::MAX, 1, 4096).expect_err("cannot fit"),
ServerError::ContextOverflow {
requested: usize::MAX,
..
}
));
}
}