use std::borrow::Cow;
use std::fmt;
use std::str::FromStr;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::TokenizerError;
use super::pyjson;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Role {
System,
User,
Assistant,
Tool,
}
impl Role {
pub fn as_str(self) -> &'static str {
match self {
Role::System => "system",
Role::User => "user",
Role::Assistant => "assistant",
Role::Tool => "tool",
}
}
}
impl fmt::Display for Role {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl FromStr for Role {
type Err = TokenizerError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"system" => Ok(Role::System),
"user" => Ok(Role::User),
"assistant" => Ok(Role::Assistant),
"tool" => Ok(Role::Tool),
other => Err(TokenizerError::UnsupportedRole(other.to_owned())),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ChatMessage {
pub role: Role,
pub content: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub tool_calls: Vec<ToolCall>,
}
impl ChatMessage {
pub fn new(role: Role, content: impl Into<String>) -> Self {
ChatMessage {
role,
content: content.into(),
tool_calls: Vec::new(),
}
}
pub fn system(content: impl Into<String>) -> Self {
Self::new(Role::System, content)
}
pub fn user(content: impl Into<String>) -> Self {
Self::new(Role::User, content)
}
pub fn assistant(content: impl Into<String>) -> Self {
Self::new(Role::Assistant, content)
}
pub fn tool(content: impl Into<String>) -> Self {
Self::new(Role::Tool, content)
}
pub fn assistant_calling(content: impl Into<String>, tool_calls: Vec<ToolCall>) -> Self {
ChatMessage {
tool_calls,
..Self::new(Role::Assistant, content)
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(from = "ToolCallRepr")]
pub struct ToolCall {
pub name: String,
pub arguments: ToolArguments,
}
impl ToolCall {
pub fn raw(name: impl Into<String>, arguments: impl Into<String>) -> Self {
ToolCall {
name: name.into(),
arguments: ToolArguments::Raw(arguments.into()),
}
}
pub fn json(name: impl Into<String>, arguments: Value) -> Self {
ToolCall {
name: name.into(),
arguments: ToolArguments::Value(arguments),
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ToolArguments {
Raw(String),
Value(Value),
}
impl Eq for ToolArguments {}
impl ToolArguments {
fn render(&self) -> Cow<'_, str> {
match self {
ToolArguments::Raw(raw) => Cow::Borrowed(raw.as_str()),
ToolArguments::Value(value) => Cow::Owned(tojson(value)),
}
}
}
#[derive(Deserialize)]
#[serde(untagged)]
enum ToolCallRepr {
Wrapped(WrappedToolCall),
Bare(BareToolCall),
}
#[derive(Deserialize)]
struct WrappedToolCall {
function: BareToolCall,
}
#[derive(Deserialize)]
struct BareToolCall {
name: String,
arguments: ToolArguments,
}
impl From<ToolCallRepr> for ToolCall {
fn from(repr: ToolCallRepr) -> Self {
let bare = match repr {
ToolCallRepr::Wrapped(wrapped) => wrapped.function,
ToolCallRepr::Bare(bare) => bare,
};
ToolCall {
name: bare.name,
arguments: bare.arguments,
}
}
}
fn tojson(value: &Value) -> String {
pyjson::to_string(value).unwrap_or_else(|_| value.to_string())
}
pub(crate) const IM_START: &str = "<|im_start|>";
pub(crate) const IM_END: &str = "<|im_end|>";
const TOOLS_PREAMBLE: &str = "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>";
const TOOLS_FOOTER: &str = "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call>";
pub(crate) fn render_chatml(
messages: &[ChatMessage],
tools: &[Value],
add_generation_prompt: bool,
) -> String {
render_turns(messages, tools, add_generation_prompt, None)
}
pub(crate) fn render_chatml_sanitized(
messages: &[ChatMessage],
tools: &[Value],
add_generation_prompt: bool,
sanitizer: &ContentSanitizer,
) -> String {
render_turns(messages, tools, add_generation_prompt, Some(sanitizer))
}
fn render_turns(
messages: &[ChatMessage],
tools: &[Value],
add_generation_prompt: bool,
sanitizer: Option<&ContentSanitizer>,
) -> String {
let content_len: usize = messages.iter().map(|m| m.content.len()).sum();
let mut out = String::with_capacity(content_len + 34 * (messages.len() + 1));
let leading_system = messages.first().filter(|m| m.role == Role::System);
if tools.is_empty() {
if let Some(system) = leading_system {
push_turn(&mut out, Role::System, &turn_content(system, sanitizer));
}
} else {
push_tools_system_block(&mut out, leading_system, tools, sanitizer);
}
for (index, message) in messages.iter().enumerate() {
if index == 0 && message.role == Role::System {
continue;
}
match message.role {
Role::Assistant => push_assistant_turn(&mut out, message, sanitizer),
Role::Tool => {
let previous = index
.checked_sub(1)
.and_then(|i| messages.get(i))
.map(|m| m.role);
let next = messages.get(index + 1).map(|m| m.role);
push_tool_response(
&mut out,
message,
previous != Some(Role::Tool),
next != Some(Role::Tool),
sanitizer,
);
}
Role::System | Role::User => {
push_turn(&mut out, message.role, &turn_content(message, sanitizer));
}
}
}
if add_generation_prompt {
out.push_str(IM_START);
out.push_str(Role::Assistant.as_str());
out.push('\n');
}
out
}
fn push_tools_system_block(
out: &mut String,
leading_system: Option<&ChatMessage>,
tools: &[Value],
sanitizer: Option<&ContentSanitizer>,
) {
out.push_str(IM_START);
out.push_str(Role::System.as_str());
out.push('\n');
if let Some(system) = leading_system {
out.push_str(&turn_content(system, sanitizer));
out.push_str("\n\n");
}
out.push_str(TOOLS_PREAMBLE);
for tool in tools {
out.push('\n');
match sanitizer {
Some(sanitizer) => out.push_str(&tojson(&sanitizer.sanitize_json(tool))),
None => out.push_str(&tojson(tool)),
}
}
out.push_str(TOOLS_FOOTER);
out.push_str(IM_END);
out.push('\n');
}
fn push_assistant_turn(
out: &mut String,
message: &ChatMessage,
sanitizer: Option<&ContentSanitizer>,
) {
let content = turn_content(message, sanitizer);
out.push_str(IM_START);
out.push_str(Role::Assistant.as_str());
out.push('\n');
out.push_str(&content);
for (index, call) in message.tool_calls.iter().enumerate() {
if index > 0 || !content.is_empty() {
out.push('\n');
}
push_tool_call(out, call, sanitizer);
}
out.push_str(IM_END);
out.push('\n');
}
fn push_tool_call(out: &mut String, call: &ToolCall, sanitizer: Option<&ContentSanitizer>) {
out.push_str("<tool_call>\n{\"name\": \"");
match sanitizer {
Some(sanitizer) => out.push_str(&sanitizer.sanitize(&call.name)),
None => out.push_str(&call.name),
}
out.push_str("\", \"arguments\": ");
match sanitizer {
Some(sanitizer) => out.push_str(&sanitizer.sanitize_arguments(&call.arguments).render()),
None => out.push_str(&call.arguments.render()),
}
out.push_str("}\n</tool_call>");
}
fn push_tool_response(
out: &mut String,
message: &ChatMessage,
opens: bool,
closes: bool,
sanitizer: Option<&ContentSanitizer>,
) {
if opens {
out.push_str(IM_START);
out.push_str(Role::User.as_str());
}
out.push_str("\n<tool_response>\n");
out.push_str(&turn_content(message, sanitizer));
out.push_str("\n</tool_response>");
if closes {
out.push_str(IM_END);
out.push('\n');
}
}
pub const SANITIZE_MARKER: char = '\u{200B}';
#[derive(Debug, Clone)]
pub struct ContentSanitizer {
literals: Vec<String>,
first_bytes: [bool; 256],
}
impl ContentSanitizer {
pub(crate) fn from_literals<I>(literals: I) -> Self
where
I: IntoIterator<Item = String>,
{
let mut literals: Vec<String> = literals.into_iter().filter(|l| !l.is_empty()).collect();
literals.sort_by(|a, b| {
a.len()
.cmp(&b.len())
.then_with(|| a.as_str().cmp(b.as_str()))
});
literals.dedup();
let mut first_bytes = [false; 256];
for literal in &literals {
if let Some(&byte) = literal.as_bytes().first() {
first_bytes[byte as usize] = true;
}
}
ContentSanitizer {
literals,
first_bytes,
}
}
pub fn literals(&self) -> impl ExactSizeIterator<Item = &str> {
self.literals.iter().map(String::as_str)
}
pub fn is_clean(&self, content: &str) -> bool {
self.find_literal(content, 0).is_none()
}
pub fn sanitize<'a>(&self, content: &'a str) -> Cow<'a, str> {
let Some((first, _)) = self.find_literal(content, 0) else {
return Cow::Borrowed(content);
};
let mut out = String::with_capacity(content.len() + SANITIZE_MARKER.len_utf8() * 8);
let mut copied = 0;
let mut cursor = first;
while let Some((at, literal)) = self.find_literal(content, cursor) {
let Some(head) = content[at..].chars().next() else {
break;
};
out.push_str(&content[copied..at]);
if literal.len() > head.len_utf8() {
out.push(head);
}
out.push(SANITIZE_MARKER);
cursor = at + head.len_utf8();
copied = cursor;
}
out.push_str(&content[copied..]);
Cow::Owned(out)
}
pub fn sanitize_json(&self, value: &Value) -> Value {
match value {
Value::String(string) => Value::String(self.sanitize(string).into_owned()),
Value::Array(items) => {
Value::Array(items.iter().map(|item| self.sanitize_json(item)).collect())
}
Value::Object(members) => Value::Object(
members
.iter()
.map(|(key, value)| {
(self.sanitize(key).into_owned(), self.sanitize_json(value))
})
.collect(),
),
scalar => scalar.clone(),
}
}
pub fn sanitize_arguments(&self, arguments: &ToolArguments) -> ToolArguments {
match arguments {
ToolArguments::Raw(raw) => ToolArguments::Raw(self.sanitize(raw).into_owned()),
ToolArguments::Value(value) => ToolArguments::Value(self.sanitize_json(value)),
}
}
pub fn sanitize_tool_call(&self, call: &ToolCall) -> ToolCall {
ToolCall {
name: self.sanitize(&call.name).into_owned(),
arguments: self.sanitize_arguments(&call.arguments),
}
}
pub fn sanitize_message(&self, message: &ChatMessage) -> ChatMessage {
ChatMessage {
role: message.role,
content: self.sanitize(&message.content).into_owned(),
tool_calls: message
.tool_calls
.iter()
.map(|call| self.sanitize_tool_call(call))
.collect(),
}
}
pub fn sanitize_messages(&self, messages: &[ChatMessage]) -> Vec<ChatMessage> {
messages.iter().map(|m| self.sanitize_message(m)).collect()
}
fn find_literal<'s>(&'s self, content: &str, from: usize) -> Option<(usize, &'s str)> {
let bytes = content.as_bytes();
let mut at = from;
while at < bytes.len() {
if self.first_bytes[bytes[at] as usize]
&& content.is_char_boundary(at)
&& let Some(literal) = self.literal_at(&content[at..])
{
return Some((at, literal));
}
at += 1;
}
None
}
fn literal_at<'s>(&'s self, rest: &str) -> Option<&'s str> {
self.literals
.iter()
.find(|literal| rest.starts_with(literal.as_str()))
.map(String::as_str)
}
}
fn turn_content<'m>(
message: &'m ChatMessage,
sanitizer: Option<&ContentSanitizer>,
) -> Cow<'m, str> {
match sanitizer {
Some(sanitizer) => sanitizer.sanitize(&message.content),
None => Cow::Borrowed(message.content.as_str()),
}
}
fn push_turn(out: &mut String, role: Role, content: &str) {
out.push_str(IM_START);
out.push_str(role.as_str());
out.push('\n');
out.push_str(content);
out.push_str(IM_END);
out.push('\n');
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn role_round_trips_through_str() {
for role in [Role::System, Role::User, Role::Assistant, Role::Tool] {
assert_eq!(role.as_str().parse::<Role>().unwrap(), role);
}
}
#[test]
fn unknown_role_is_a_typed_error() {
assert!(matches!(
"function".parse::<Role>().unwrap_err(),
TokenizerError::UnsupportedRole(r) if r == "function"
));
assert!(matches!(
"System".parse::<Role>().unwrap_err(),
TokenizerError::UnsupportedRole(_)
));
}
#[test]
fn message_json_rejects_unknown_roles_and_fields() {
assert!(
serde_json::from_str::<ChatMessage>(r#"{"role":"developer","content":"x"}"#).is_err()
);
assert!(
serde_json::from_str::<ChatMessage>(r#"{"role":"user","content":"x","name":"bob"}"#)
.is_err()
);
let ok: ChatMessage = serde_json::from_str(r#"{"role":"user","content":"hi"}"#).unwrap();
assert_eq!(ok, ChatMessage::user("hi"));
let tool: ChatMessage = serde_json::from_str(r#"{"role":"tool","content":"31C"}"#).unwrap();
assert_eq!(tool, ChatMessage::tool("31C"));
let empty: ChatMessage =
serde_json::from_str(r#"{"role":"assistant","content":"","tool_calls":[]}"#).unwrap();
assert_eq!(empty, ChatMessage::assistant(""));
}
#[test]
fn tool_calls_parse_from_both_template_shapes() {
let bare: ChatMessage = serde_json::from_str(
r#"{"role":"assistant","content":"","tool_calls":[{"name":"f","arguments":{"a":1}}]}"#,
)
.unwrap();
let wrapped: ChatMessage = serde_json::from_str(
r#"{"role":"assistant","content":"","tool_calls":[
{"id":"call_1","type":"function","function":{"name":"f","arguments":{"a":1}}}]}"#,
)
.unwrap();
assert_eq!(bare, wrapped);
assert_eq!(
bare.tool_calls,
[ToolCall::json("f", serde_json::json!({"a": 1}))]
);
let raw: ChatMessage = serde_json::from_str(
r#"{"role":"assistant","content":"","tool_calls":[{"name":"f","arguments":"{ nonsense"}]}"#,
)
.unwrap();
assert_eq!(raw.tool_calls, [ToolCall::raw("f", "{ nonsense")]);
for message in [&bare, &raw] {
let json = serde_json::to_string(message).unwrap();
assert_eq!(
&serde_json::from_str::<ChatMessage>(&json).unwrap(),
message
);
}
assert_eq!(
serde_json::to_string(&ChatMessage::user("hi")).unwrap(),
r#"{"role":"user","content":"hi"}"#
);
}
#[test]
fn empty_conversation_renders_only_the_generation_prompt() {
assert_eq!(render_chatml(&[], &[], true), "<|im_start|>assistant\n");
assert_eq!(render_chatml(&[], &[], false), "");
}
#[test]
fn leading_system_is_rendered_once() {
let rendered = render_chatml(
&[ChatMessage::system("sys"), ChatMessage::user("hi")],
&[],
true,
);
assert_eq!(
rendered,
"<|im_start|>system\nsys<|im_end|>\n\
<|im_start|>user\nhi<|im_end|>\n\
<|im_start|>assistant\n"
);
}
#[test]
fn whitespace_only_assistant_content_still_gets_its_separator() {
let call = ToolCall::json("f", serde_json::json!({}));
let blank = render_chatml(
&[ChatMessage::assistant_calling(" ", vec![call.clone()])],
&[],
false,
);
assert_eq!(
blank,
"<|im_start|>assistant\n \n<tool_call>\n{\"name\": \"f\", \"arguments\": {}}\n</tool_call><|im_end|>\n"
);
let empty = render_chatml(
&[ChatMessage::assistant_calling("", vec![call])],
&[],
false,
);
assert_eq!(
empty,
"<|im_start|>assistant\n<tool_call>\n{\"name\": \"f\", \"arguments\": {}}\n</tool_call><|im_end|>\n"
);
}
#[test]
fn a_run_of_tool_results_opens_and_closes_exactly_one_turn() {
let rendered = render_chatml(
&[
ChatMessage::tool("a"),
ChatMessage::tool("b"),
ChatMessage::user("and?"),
ChatMessage::tool("c"),
],
&[],
false,
);
assert_eq!(
rendered,
"<|im_start|>user\n<tool_response>\na\n</tool_response>\n\
<tool_response>\nb\n</tool_response><|im_end|>\n\
<|im_start|>user\nand?<|im_end|>\n\
<|im_start|>user\n<tool_response>\nc\n</tool_response><|im_end|>\n"
);
assert_eq!(rendered.matches(IM_START).count(), 3);
assert_eq!(rendered.matches(IM_END).count(), 3);
}
#[test]
fn a_leading_system_message_still_counts_as_the_previous_role() {
let rendered = render_chatml(
&[ChatMessage::system("s"), ChatMessage::tool("r")],
&[],
false,
);
assert_eq!(
rendered,
"<|im_start|>system\ns<|im_end|>\n\
<|im_start|>user\n<tool_response>\nr\n</tool_response><|im_end|>\n"
);
}
#[test]
fn an_empty_tools_slice_is_the_plain_chat_branch() {
let messages = [ChatMessage::system("s"), ChatMessage::user("hi")];
assert_eq!(
render_chatml(&messages, &[], true),
"<|im_start|>system\ns<|im_end|>\n\
<|im_start|>user\nhi<|im_end|>\n\
<|im_start|>assistant\n"
);
let with_tools = render_chatml(&messages, &[serde_json::json!({"type": "function"})], true);
assert!(with_tools.contains("# Tools"));
assert_eq!(with_tools.matches("<|im_start|>system").count(), 1);
}
fn test_sanitizer() -> ContentSanitizer {
ContentSanitizer::from_literals(
["<|a|>", "<a>", "<|abc|>", "@", "\u{4e2d}x"]
.into_iter()
.map(String::from),
)
}
fn strip_markers(s: &str) -> String {
s.replace(SANITIZE_MARKER, "")
}
#[test]
fn sanitizer_literals_are_deduplicated_and_shortest_first() {
let sanitizer = ContentSanitizer::from_literals(
["bb", "a", "bb", "", "ccc"].into_iter().map(String::from),
);
let literals: Vec<&str> = sanitizer.literals().collect();
assert_eq!(literals, ["a", "bb", "ccc"]);
}
#[test]
fn clean_content_is_borrowed_unchanged() {
let sanitizer = test_sanitizer();
for content in [
"",
" \n\t ",
"system",
"<|a",
"a|>",
"< | a | >",
"<b>",
"\u{4e2d}",
] {
assert!(sanitizer.is_clean(content), "{content:?}");
assert!(
matches!(sanitizer.sanitize(content), Cow::Borrowed(_)),
"{content:?} should not allocate"
);
assert_eq!(sanitizer.sanitize(content), content);
}
}
#[test]
fn a_broken_literal_keeps_every_original_character() {
let sanitizer = test_sanitizer();
let sanitized = sanitizer.sanitize("what does <|a|> mean?").into_owned();
assert_ne!(sanitized, "what does <|a|> mean?");
assert!(sanitizer.is_clean(&sanitized));
assert_eq!(strip_markers(&sanitized), "what does <|a|> mean?");
}
#[test]
fn one_character_literals_are_replaced_not_split() {
let sanitizer = test_sanitizer();
let sanitized = sanitizer.sanitize("a@b").into_owned();
assert!(sanitizer.is_clean(&sanitized));
assert_eq!(sanitized, format!("a{SANITIZE_MARKER}b"));
}
#[test]
fn nested_and_overlapping_literals_are_all_broken() {
let sanitizer = test_sanitizer();
for content in [
"<|<|a|>a|>", "<|a<|a|>|>", "<|abc|>", "<|a|><|abc|><a>", "<a<a>>", "<|a|><|a|><|a|>", "<|a|>tail", "head<|a|>", "<|a|>", "x<|a|>y", "\u{4e2d}\u{4e2d}x", ] {
let sanitized = sanitizer.sanitize(content).into_owned();
assert!(
sanitizer.is_clean(&sanitized),
"{content:?} -> {sanitized:?}"
);
assert!(sanitizer.is_clean(&sanitizer.sanitize(&sanitized)));
}
}
#[test]
fn sanitizing_never_leaves_a_literal_for_any_short_string() {
let sanitizer =
ContentSanitizer::from_literals(["<|a|>", "<a>", "@"].into_iter().map(String::from));
let alphabet = ['<', '>', '|', 'a', '@'];
let base = alphabet.len();
let mut content = String::new();
let mut checked = 0usize;
for len in 0..=6u32 {
for mut word in 0..base.pow(len) {
content.clear();
for _ in 0..len {
content.push(alphabet[word % base]);
word /= base;
}
let sanitized = sanitizer.sanitize(&content).into_owned();
assert!(
sanitizer.is_clean(&sanitized),
"{content:?} -> {sanitized:?}"
);
assert_eq!(
strip_markers(&sanitized),
content.replace('@', ""),
"{content:?}"
);
checked += 1;
}
}
assert_eq!(checked, 19_531, "expected the full sweep");
}
#[test]
fn sanitizing_huge_content_neither_panics_nor_misses() {
let sanitizer = test_sanitizer();
let mut content = String::new();
while content.len() < 1 << 20 {
content.push_str("lorem ipsum <|a|> dolor @ sit \u{4e2d}x amet ");
}
let sanitized = sanitizer.sanitize(&content).into_owned();
assert!(sanitizer.is_clean(&sanitized));
}
#[test]
fn sanitized_render_keeps_the_chatml_structure() {
let sanitizer = test_sanitizer();
let messages = [ChatMessage::system("s"), ChatMessage::user("<|a|>")];
let rendered = render_chatml_sanitized(&messages, &[], true, &sanitizer);
assert_eq!(
strip_markers(&rendered),
render_chatml(&messages, &[], true),
"sanitizing must only insert markers, never change the structure"
);
}
#[test]
fn sanitizing_messages_covers_every_role() {
let sanitizer = test_sanitizer();
let messages = [
ChatMessage::system("<|a|>"),
ChatMessage::user("<a>"),
ChatMessage::assistant("<|abc|>"),
ChatMessage::tool("<|a|>"),
];
for message in sanitizer.sanitize_messages(&messages) {
assert!(sanitizer.is_clean(&message.content), "{message:?}");
}
}
#[test]
fn sanitizing_a_json_tree_rewrites_strings_and_keys_only() {
let sanitizer = test_sanitizer();
let tool = serde_json::json!({
"<|a|>key": "<a>value",
"nested": {"list": ["<|abc|>", 1, 2.5, null, true]},
"clean": "nothing to do",
});
let sanitized = sanitizer.sanitize_json(&tool);
let rendered = tojson(&sanitized);
assert!(sanitizer.is_clean(&rendered), "{rendered}");
assert_eq!(strip_markers(&rendered), tojson(&tool));
assert!(rendered.contains("2.5") && rendered.contains("null"));
assert_eq!(
serde_json::from_str::<Value>(&rendered).unwrap()["clean"],
serde_json::json!("nothing to do")
);
}
#[test]
fn sanitizing_a_tool_call_covers_the_name_and_both_argument_forms() {
let sanitizer = test_sanitizer();
let raw = sanitizer.sanitize_tool_call(&ToolCall::raw("<|a|>rm", "{\"x\":\"<a>\"}"));
assert!(sanitizer.is_clean(&raw.name));
assert!(sanitizer.is_clean(&raw.arguments.render()));
assert_eq!(strip_markers(&raw.arguments.render()), "{\"x\":\"<a>\"}");
let value = sanitizer.sanitize_tool_call(&ToolCall::json(
"<|a|>rm",
serde_json::json!({"p": "<|abc|>"}),
));
assert!(sanitizer.is_clean(&value.name));
assert!(sanitizer.is_clean(&value.arguments.render()));
let benign = ToolCall::json("get_weather", serde_json::json!({"city": "Cairo"}));
assert_eq!(sanitizer.sanitize_tool_call(&benign), benign);
}
}