#![cfg(test)]
use crate::opaque::{Envelope, Payload};
use crate::redact_tests::{SECRET, assert_redacted, assert_states};
use crate::value::content::{
Metadata, MetadataValue, Part, PartFields, PartKind, Segment, SegmentExtensions,
};
use crate::value::tool_call::{self, Id, MetadataPresence, ToolCall, ToolOutput, ToolPart};
use super::item::{Assistant, Item, ModelVisibility, System, ToolResult, User};
fn envelope(namespace: &str, kind: &str, data: &[u8]) -> Envelope {
Envelope::try_new(
namespace.into(),
kind.into(),
Payload::copy_from_slice(data),
)
.expect("test envelope is valid")
}
fn metadata_bytes(metadata: &Metadata) -> &[u8] {
match metadata.get("bytes") {
Some(MetadataValue::Bytes(bytes)) => bytes,
_ => panic!("bytes metadata missing"),
}
}
fn extensions(raw: Option<Vec<u8>>, provider_data: Option<Vec<Envelope>>) -> SegmentExtensions {
SegmentExtensions::new(
"signature".into(),
raw.map(Payload::from_vec),
provider_data,
)
}
#[test]
fn every_closed_item_variant_is_constructible_and_observable() {
let user = User::new(vec![Part::text("question".into())], ModelVisibility::Hidden);
assert_eq!(user.parts()[0].fields().text(), "question");
assert_eq!(user.visibility(), ModelVisibility::Hidden);
let assistant = Assistant::new(
vec![Segment::Text {
text: "answer".into(),
extensions: extensions(None, None),
}],
None,
)
.with_visibility(ModelVisibility::Hidden);
assert_eq!(assistant.content().len(), 1);
assert!(assistant.provider_data().is_none());
assert_eq!(assistant.visibility(), ModelVisibility::Hidden);
let result = ToolResult::new(
Id::new("call".into()),
tool_call::Name::new("search".into()),
tool_call::ToolResult::success_text("found".into()),
ModelVisibility::Visible,
None,
);
assert_eq!(result.call_id().as_str(), "call");
assert_eq!(result.tool_name().as_str(), "search");
assert!(result.result().has_output());
assert_eq!(result.visibility(), ModelVisibility::Visible);
assert!(result.metadata().is_none());
assert!(!result.is_business_error());
let system = System::new(
"instruction".into(),
"be helpful".into(),
ModelVisibility::Visible,
);
assert_eq!(system.subtype(), "instruction");
assert_eq!(system.text(), "be helpful");
assert_eq!(system.visibility(), ModelVisibility::Visible);
let items = [
Item::User(user),
Item::Assistant(assistant),
Item::ToolResult(result),
Item::System(system),
];
assert!(matches!(&items[0], Item::User(_)));
assert!(matches!(&items[1], Item::Assistant(_)));
assert!(matches!(&items[2], Item::ToolResult(_)));
assert!(matches!(&items[3], Item::System(_)));
}
#[test]
fn assistant_content_preserves_interleaved_source_order() {
let call = |id: &str, name: &str| {
ToolCall::new(
Id::new(id.into()),
tool_call::Name::new(name.into()),
Payload::copy_from_slice(br#"{"argument":true}"#),
)
};
let item = Assistant::new(
vec![
Segment::Text {
text: "before".into(),
extensions: extensions(None, None),
},
Segment::ToolCall {
call: call("first", "search"),
extensions: extensions(None, None),
},
Segment::Thinking {
text: "reason".into(),
extensions: extensions(None, None),
},
Segment::Text {
text: "after".into(),
extensions: extensions(None, None),
},
Segment::ToolCall {
call: call("second", "fetch"),
extensions: extensions(None, None),
},
],
None,
);
assert!(matches!(&item.content()[0], Segment::Text { text, .. } if text == "before"));
assert!(
matches!(&item.content()[1], Segment::ToolCall { call, .. } if call.id().as_str() == "first")
);
assert!(matches!(&item.content()[2], Segment::Thinking { text, .. } if text == "reason"));
assert!(matches!(&item.content()[3], Segment::Text { text, .. } if text == "after"));
assert!(
matches!(&item.content()[4], Segment::ToolCall { call, .. } if call.id().as_str() == "second")
);
}
#[test]
fn optional_metadata_and_provider_data_preserve_presence() {
let absent = Assistant::new(vec![], None);
let empty = Assistant::new(vec![], Some(vec![]));
let present = Assistant::new(
vec![],
Some(vec![envelope("provider", "response", br#"{"id":1}"#)]),
);
assert!(absent.provider_data().is_none());
assert!(empty.provider_data().is_some_and(<[_]>::is_empty));
assert_eq!(
present.provider_data().expect("present")[0].namespace(),
"provider"
);
let make_result = |metadata| {
ToolResult::new(
Id::new(String::new()),
tool_call::Name::new(String::new()),
tool_call::ToolResult::no_output(),
ModelVisibility::Visible,
metadata,
)
};
let absent = make_result(None);
let empty = make_result(Some(Metadata::new()));
let populated = make_result(Some(Metadata::from_iter([(
"source".to_owned(),
MetadataValue::String("tool".into()),
)])));
assert!(absent.metadata().is_none());
assert_eq!(empty.metadata().expect("present empty").iter().count(), 0);
assert!(matches!(
populated.metadata().expect("present").get("source"),
Some(MetadataValue::String(value)) if value == "tool"
));
}
#[test]
fn tool_result_error_is_derived_only_from_closed_result_state() {
let item = |result| {
ToolResult::new(
Id::new("call".into()),
tool_call::Name::new("tool".into()),
result,
ModelVisibility::Visible,
None,
)
};
let output = || ToolOutput::new(vec![], None, None, MetadataPresence::Absent);
assert!(!item(tool_call::ToolResult::no_output()).is_business_error());
assert!(!item(tool_call::ToolResult::success(output())).is_business_error());
assert!(item(tool_call::ToolResult::business_error(output())).is_business_error());
}
#[test]
fn cloned_items_recursively_own_reference_bearing_data() {
let part = Part::new(
PartKind::from_i64(2),
PartFields::new(
"part".into(),
"application/octet-stream".into(),
Some(vec![1, 2].into_boxed_slice()),
"reference".into(),
Some(Metadata::from_iter([(
"bytes".to_owned(),
MetadataValue::Bytes(vec![3, 4].into_boxed_slice()),
)])),
Some(Payload::from_vec(vec![5, 6])),
),
);
let user = Item::User(User::new(vec![part], ModelVisibility::Visible));
let cloned = user.clone();
let (Item::User(source), Item::User(copy)) = (&user, &cloned) else {
panic!("variant changed while cloning");
};
let source_fields = source.parts()[0].fields();
let copy_fields = copy.parts()[0].fields();
assert_ne!(
source_fields.data().expect("data").as_ptr(),
copy_fields.data().expect("data").as_ptr()
);
assert_ne!(
source_fields
.raw_payload()
.expect("raw")
.as_bytes()
.as_ptr(),
copy_fields.raw_payload().expect("raw").as_bytes().as_ptr()
);
assert_ne!(
metadata_bytes(source_fields.metadata().expect("metadata")).as_ptr(),
metadata_bytes(copy_fields.metadata().expect("metadata")).as_ptr()
);
let assistant = Item::Assistant(Assistant::new(
vec![Segment::ToolCall {
call: ToolCall::new(
Id::new("id".into()),
tool_call::Name::new("name".into()),
Payload::from_vec(vec![7, 8]),
),
extensions: extensions(
Some(vec![9, 10]),
Some(vec![envelope("provider", "segment", br#"{"x":1}"#)]),
),
}],
Some(vec![envelope("provider", "response", br#"{"y":2}"#)]),
));
let cloned = assistant.clone();
let (Item::Assistant(source), Item::Assistant(copy)) = (&assistant, &cloned) else {
panic!("variant changed while cloning");
};
let (
Segment::ToolCall {
call: source_call,
extensions: source_extensions,
},
Segment::ToolCall {
call: copy_call,
extensions: copy_extensions,
},
) = (&source.content()[0], ©.content()[0])
else {
panic!("segment changed while cloning");
};
assert_ne!(
source_call.arguments().as_bytes().as_ptr(),
copy_call.arguments().as_bytes().as_ptr()
);
assert_ne!(
source_extensions
.raw_payload()
.expect("raw")
.as_bytes()
.as_ptr(),
copy_extensions
.raw_payload()
.expect("raw")
.as_bytes()
.as_ptr()
);
assert_ne!(
source_extensions.provider_data().expect("provider")[0]
.data()
.as_bytes()
.as_ptr(),
copy_extensions.provider_data().expect("provider")[0]
.data()
.as_bytes()
.as_ptr()
);
assert_ne!(
source.provider_data().expect("provider")[0]
.data()
.as_bytes()
.as_ptr(),
copy.provider_data().expect("provider")[0]
.data()
.as_bytes()
.as_ptr()
);
}
#[test]
fn tool_result_and_system_clones_are_owned_and_keep_metadata_lanes_separate() {
let tool_part = ToolPart::try_from_part(Part::text("result".into())).expect("known kind");
let output = ToolOutput::new(
vec![tool_part],
Some("user".into()),
Some("log".into()),
MetadataPresence::Present(Metadata::from_iter([(
"result".to_owned(),
MetadataValue::Bytes(vec![1].into_boxed_slice()),
)])),
);
let original = Item::ToolResult(ToolResult::new(
Id::new("call".into()),
tool_call::Name::new("tool".into()),
tool_call::ToolResult::success(output),
ModelVisibility::Visible,
Some(Metadata::from_iter([(
"item".to_owned(),
MetadataValue::Bytes(vec![2].into_boxed_slice()),
)])),
));
let cloned = original.clone();
let (Item::ToolResult(source), Item::ToolResult(copy)) = (&original, &cloned) else {
panic!("variant changed while cloning");
};
assert_ne!(
source.call_id().as_str().as_ptr(),
copy.call_id().as_str().as_ptr()
);
assert_ne!(
source.tool_name().as_str().as_ptr(),
copy.tool_name().as_str().as_ptr()
);
assert!(matches!(
source.result().output().expect("output").metadata(),
MetadataPresence::Present(metadata) if metadata.get("result").is_some()
));
assert!(
source
.metadata()
.expect("item metadata")
.get("result")
.is_none()
);
assert!(
source
.metadata()
.expect("item metadata")
.get("item")
.is_some()
);
assert!(
copy.metadata()
.expect("item metadata")
.get("item")
.is_some()
);
let original = Item::System(System::new(
"type".into(),
"text".into(),
ModelVisibility::Visible,
));
let cloned = original.clone();
let (Item::System(source), Item::System(copy)) = (&original, &cloned) else {
panic!("variant changed while cloning");
};
assert_ne!(source.subtype().as_ptr(), copy.subtype().as_ptr());
assert_ne!(source.text().as_ptr(), copy.text().as_ptr());
}
#[test]
fn system_debug_prints_the_subtype_and_sizes_the_instruction() {
let system = System::new(
"instruction".into(),
SECRET.into(),
ModelVisibility::Visible,
);
assert_redacted(&system);
assert_eq!(
format!("{system:?}"),
r#"System { subtype: "instruction", text: <21 bytes>, visibility: Visible }"#
);
}
#[test]
fn item_debug_redacts_through_every_variant_and_keeps_visibility() {
let items = [
Item::User(User::new(
vec![Part::text(SECRET.into())],
ModelVisibility::Hidden,
)),
Item::Assistant(
Assistant::new(
vec![Segment::Text {
text: SECRET.into(),
extensions: SegmentExtensions::new(SECRET.into(), None, None),
}],
None,
)
.with_visibility(ModelVisibility::Hidden),
),
Item::ToolResult(ToolResult::new(
Id::new("call-1".into()),
tool_call::Name::new("search".into()),
crate::value::tool_call::ToolResult::success_text(SECRET.into()),
ModelVisibility::Visible,
Some(Metadata::from_iter([(
"secret".to_owned(),
MetadataValue::String(SECRET.into()),
)])),
)),
Item::System(System::new(
"instruction".into(),
SECRET.into(),
ModelVisibility::Visible,
)),
];
for item in &items {
assert_redacted(item);
assert!(
format!("{item:?}").contains("visibility: Visible")
|| format!("{item:?}").contains("visibility: Hidden"),
"an item dropped its visibility: {item:?}"
);
}
assert_states(&items[0], &["User", "text: <21 bytes>"]);
assert_states(&items[1], &["Assistant", "signature: <present>"]);
assert_states(
&items[2],
&[
"ToolResult",
r#"Id("call-1")"#,
"metadata: Some(Metadata { entries: 1 })",
],
);
}
#[test]
fn plain_text_renders_every_record_and_omits_what_is_not_text() {
let user = Item::User(User::new(
vec![
Part::text("first block".into()),
Part::new(
PartKind::from_i64(1),
PartFields::new(
String::new(),
"image/png".into(),
Some(Box::from(&b"\x89PNG"[..])),
String::new(),
None,
None,
),
),
Part::text("second block".into()),
],
ModelVisibility::Visible,
));
assert_eq!(user.to_plain_text(), "first block\nsecond block");
let assistant = Item::Assistant(Assistant::new(
vec![
Segment::Thinking {
text: "deliberation".into(),
extensions: extensions(None, None),
},
Segment::Text {
text: "the answer".into(),
extensions: extensions(None, None),
},
Segment::ToolCall {
call: ToolCall::new(
Id::new("call-1".into()),
tool_call::Name::new("search".into()),
Payload::copy_from_slice(b"{}"),
),
extensions: extensions(None, None),
},
],
None,
));
assert_eq!(assistant.to_plain_text(), "the answer");
let system = Item::System(System::new(
"instruction".into(),
"Be concise.".into(),
ModelVisibility::Visible,
));
assert_eq!(system.to_plain_text(), "Be concise.");
let rendered = Item::ToolResult(ToolResult::new(
Id::new("call-1".into()),
tool_call::Name::new("search".into()),
tool_call::ToolResult::success_text("three matches".into()),
ModelVisibility::Visible,
None,
));
assert_eq!(rendered.to_plain_text(), "three matches");
let model_only = Item::ToolResult(ToolResult::new(
Id::new("call-2".into()),
tool_call::Name::new("search".into()),
tool_call::ToolResult::success(ToolOutput::new(
vec![
ToolPart::try_from_part(Part::text("row one".into())).expect("known kind"),
ToolPart::try_from_part(Part::text("row two".into())).expect("known kind"),
],
None,
None,
MetadataPresence::Absent,
)),
ModelVisibility::Visible,
None,
));
assert_eq!(model_only.to_plain_text(), "row one\nrow two");
let silent = Item::ToolResult(ToolResult::new(
Id::new("call-3".into()),
tool_call::Name::new("search".into()),
tool_call::ToolResult::no_output(),
ModelVisibility::Visible,
None,
));
assert!(silent.to_plain_text().is_empty());
}
#[test]
fn the_tool_result_arm_renders_exactly_what_the_closed_result_renders() {
let part = |text: &str| {
ToolPart::try_from_part(Part::text(text.to_owned())).expect("text is a known kind")
};
let results = [
tool_call::ToolResult::success(ToolOutput::new(
vec![part("row one"), part("row two")],
Some("2 matches".into()),
None,
MetadataPresence::Absent,
)),
tool_call::ToolResult::success(ToolOutput::new(
vec![part("row one")],
None,
None,
MetadataPresence::Absent,
)),
tool_call::ToolResult::no_output(),
];
for result in results {
let expected = result.to_plain_text();
let record = Item::ToolResult(ToolResult::new(
Id::new("call-1".into()),
tool_call::Name::new("search".into()),
result,
ModelVisibility::Hidden,
Some(Metadata::new()),
));
assert_eq!(record.to_plain_text(), expected);
}
assert_eq!(
Item::ToolResult(ToolResult::new(
Id::new("call-1".into()),
tool_call::Name::new("search".into()),
tool_call::ToolResult::success(ToolOutput::new(
vec![part("row one"), part("row two")],
Some("2 matches".into()),
None,
MetadataPresence::Absent,
)),
ModelVisibility::Visible,
None,
))
.to_plain_text(),
"2 matches"
);
}
#[cfg(feature = "serde")]
mod serde_format {
use super::super::item::{Assistant, Item, ModelVisibility, System, ToolResult, User};
use crate::value::content::{Metadata, Part, Segment, SegmentExtensions};
use crate::value::tool_call::{self, Id, Name};
use crate::wire::wire_tests::{assert_expecting, assert_refusal, encode, round_trip};
fn visibility_of(record: &Item) -> ModelVisibility {
match record {
Item::User(user) => user.visibility(),
Item::Assistant(assistant) => assistant.visibility(),
Item::ToolResult(result) => result.visibility(),
Item::System(system) => system.visibility(),
}
}
fn call_segment() -> Segment {
Segment::ToolCall {
call: tool_call::ToolCall::new(
Id::new("call-1".into()),
Name::new("search".into()),
crate::opaque::Payload::copy_from_slice(b"{}"),
),
extensions: SegmentExtensions::new(String::new(), None, None),
}
}
#[test]
fn both_visibilities_survive_a_round_trip() {
assert_eq!(encode(&ModelVisibility::Visible), r#""both""#);
assert_eq!(encode(&ModelVisibility::Hidden), r#""user_only""#);
assert_eq!(
round_trip(&ModelVisibility::Hidden),
ModelVisibility::Hidden
);
assert_refusal(
serde_json::from_str::<ModelVisibility>(r#""model_only""#),
"unknown variant `model_only`",
);
assert_expecting::<ModelVisibility>("a record visibility");
}
#[test]
fn a_user_record_reads_from_both_forms_and_refuses_the_rest() {
let user = User::new(vec![Part::text("hi".into())], ModelVisibility::Hidden);
let restored = round_trip(&user);
assert_eq!(restored.visibility(), ModelVisibility::Hidden);
assert_eq!(encode(&restored), encode(&user));
let from_sequence: User =
serde_json::from_str(r#"[[],"both"]"#).expect("the sequence form reads");
assert_eq!(from_sequence.visibility(), ModelVisibility::Visible);
assert_refusal(
serde_json::from_str::<User>(r#"{"parts":[],"content":[]}"#),
"unknown field `content`",
);
assert_refusal(
serde_json::from_str::<User>(r#"{"parts":[],"parts":[]}"#),
"duplicate field `parts`",
);
assert_refusal(
serde_json::from_str::<User>(r#"{"parts":[]}"#),
"missing field `visibility`",
);
assert_refusal(serde_json::from_str::<User>("[[]]"), "every struct field");
assert_expecting::<User>("a user record");
}
#[test]
fn an_assistant_record_carries_a_visibility_its_constructor_does_not_take() {
let hidden =
Assistant::new(vec![call_segment()], None).with_visibility(ModelVisibility::Hidden);
let restored = round_trip(&hidden);
assert_eq!(restored.visibility(), ModelVisibility::Hidden);
assert_eq!(encode(&restored), encode(&hidden));
let visible = Assistant::new(Vec::new(), Some(Vec::new()));
assert_eq!(round_trip(&visible).visibility(), ModelVisibility::Visible);
assert_ne!(encode(&visible), encode(&hidden));
let from_sequence: Assistant =
serde_json::from_str(r#"[[],null,"user_only"]"#).expect("the sequence form reads");
assert_eq!(from_sequence.visibility(), ModelVisibility::Hidden);
assert_refusal(
serde_json::from_str::<Assistant>(r#"{"content":[],"segments":[]}"#),
"unknown field `segments`",
);
assert_refusal(
serde_json::from_str::<Assistant>(r#"{"content":[],"content":[]}"#),
"duplicate field `content`",
);
assert_refusal(
serde_json::from_str::<Assistant>(r#"{"content":[],"provider_data":null}"#),
"missing field `visibility`",
);
assert_refusal(
serde_json::from_str::<Assistant>("[[]]"),
"every struct field",
);
assert_expecting::<Assistant>("an assistant record");
}
#[test]
fn a_tool_result_record_reads_from_both_forms_and_refuses_the_rest() {
let record = ToolResult::new(
Id::new("call-1".into()),
Name::new("search".into()),
tool_call::ToolResult::no_output(),
ModelVisibility::Hidden,
Some(Metadata::new()),
);
let restored = round_trip(&record);
assert_eq!(restored.visibility(), ModelVisibility::Hidden);
assert_eq!(encode(&restored), encode(&record));
let from_sequence: ToolResult =
serde_json::from_str(r#"["c","t","no_output","both",null]"#)
.expect("the sequence form reads");
assert_eq!(from_sequence.visibility(), ModelVisibility::Visible);
assert!(from_sequence.metadata().is_none());
assert_refusal(
serde_json::from_str::<ToolResult>(r#"{"call_id":"c","id":"c"}"#),
"unknown field `id`",
);
assert_refusal(
serde_json::from_str::<ToolResult>(r#"{"call_id":"c","call_id":"c"}"#),
"duplicate field `call_id`",
);
assert_refusal(
serde_json::from_str::<ToolResult>(
r#"{"call_id":"c","tool_name":"t","result":"no_output","visibility":"both"}"#,
),
"missing field `metadata`",
);
assert_refusal(
serde_json::from_str::<ToolResult>(r#"["c"]"#),
"every struct field",
);
assert_expecting::<ToolResult>("a tool-result record");
}
#[test]
fn a_system_record_reads_from_both_forms_and_refuses_the_rest() {
let system = System::new(
"instruction".into(),
"Be brief.".into(),
ModelVisibility::Hidden,
);
let restored = round_trip(&system);
assert_eq!(restored.visibility(), ModelVisibility::Hidden);
assert_eq!(encode(&restored), encode(&system));
let from_sequence: System =
serde_json::from_str(r#"["","","both"]"#).expect("the sequence form reads");
assert_eq!(from_sequence.subtype(), "");
assert_refusal(
serde_json::from_str::<System>(r#"{"subtype":"","kind":""}"#),
"unknown field `kind`",
);
assert_refusal(
serde_json::from_str::<System>(r#"{"subtype":"","subtype":""}"#),
"duplicate field `subtype`",
);
assert_refusal(
serde_json::from_str::<System>(r#"{"subtype":"","text":""}"#),
"missing field `visibility`",
);
assert_refusal(
serde_json::from_str::<System>(r#"[""]"#),
"every struct field",
);
assert_expecting::<System>("a system record");
}
#[test]
fn every_item_variant_survives_a_round_trip_with_its_visibility() {
let records = [
Item::User(User::new(Vec::new(), ModelVisibility::Hidden)),
Item::Assistant(
Assistant::new(Vec::new(), None).with_visibility(ModelVisibility::Hidden),
),
Item::ToolResult(ToolResult::new(
Id::new("c".into()),
Name::new("t".into()),
tool_call::ToolResult::no_output(),
ModelVisibility::Hidden,
None,
)),
Item::System(System::new(
String::new(),
String::new(),
ModelVisibility::Hidden,
)),
];
for record in &records {
let restored = round_trip(record);
assert_eq!(visibility_of(&restored), ModelVisibility::Hidden);
assert_eq!(encode(&restored), encode(record));
}
assert_refusal(
serde_json::from_str::<Item>(r#"{"tool_call":null}"#),
"unknown variant `tool_call`",
);
assert_expecting::<Item>("a transcript record");
}
}