//! SMH-SPEC-SPEC0001: atomic tool completion wire boundary. use super::*; use crate::metadata::{ToolMutationMetadata, encode}; use crate::session::{EntryContent, TOOL_MUTATION_KIND}; use smith::error::MutationState; use smith::message::{ContentBlock, Message}; fn completion() -> (EntryId, ToolCallId, [EntryFrame; 3]) { let submission_id = EntryId::new(); let call_id = ToolCallId::new(); let result = EntryFrame::new( Some(submission_id), &EntryContent::ToolResult { call_id, ok: true, output: "written".into(), }, ) .unwrap(); let evidence = EntryFrame::new( Some(result.id), &EntryContent::Meta { kind: TOOL_MUTATION_KIND.into(), detail: encode(&ToolMutationMetadata::new(call_id, MutationState::Applied)).unwrap(), }, ) .unwrap(); let mut message = Message::new(Role::Tool); message.add_block(ContentBlock::tool_result(call_id, true, "written")); let conversation = EntryFrame::new(Some(evidence.id), &EntryContent::Message(message)).unwrap(); (submission_id, call_id, [result, evidence, conversation]) } #[test] fn required_completion_envelope_is_one_recoverable_frame() { let (submission_id, call_id, entries) = completion(); let bytes = raw_completion( ToolCompletionCheckpoint { submission_id, call_id, }, &entries, ); let recovered = read_frames(&mut bytes.as_slice(), DEFAULT_MAX_FRAME_BYTES); assert!( recovered.is_ok(), "completion envelope must decode atomically: {recovered:?}" ); assert_eq!(recovered.unwrap().frames.len(), 1); } fn raw_completion(checkpoint: ToolCompletionCheckpoint, entries: &[EntryFrame]) -> Vec { let mut payload = checkpoint.submission_id.as_u128().to_le_bytes().to_vec(); payload.extend_from_slice(&checkpoint.call_id.as_u128().to_le_bytes()); for entry in entries { payload.extend( Frame::Known { entry: entry.clone(), } .encode(DEFAULT_MAX_FRAME_BYTES) .unwrap(), ); } Frame::Unknown { kind: KIND_COMMIT, version: 1, payload, } .encode(DEFAULT_MAX_FRAME_BYTES) .unwrap() } #[test] fn checksum_valid_completion_schema_errors_publish_no_member() { let (submission_id, call_id, entries) = completion(); let checkpoint = ToolCompletionCheckpoint { submission_id, call_id, }; let mut wrong_role = entries.clone(); wrong_role[2] = EntryFrame::new( Some(entries[1].id), &EntryContent::Message(Message::with_text(Role::User, "forged")), ) .unwrap(); let mut wrong_pair = entries.clone(); wrong_pair[1] = EntryFrame::new( Some(entries[0].id), &EntryContent::Meta { kind: TOOL_MUTATION_KIND.into(), detail: encode(&ToolMutationMetadata::new( ToolCallId::new(), MutationState::Unknown, )) .unwrap(), }, ) .unwrap(); wrong_pair[2].parent = Some(wrong_pair[1].id); let mut extra = entries.to_vec(); extra.push(entries[0].clone()); for invalid in [wrong_role.to_vec(), wrong_pair.to_vec(), extra] { let bytes = raw_completion(checkpoint, &invalid); assert!(read_frames(&mut bytes.as_slice(), DEFAULT_MAX_FRAME_BYTES).is_err()); let mut seen = 0; assert!( visit_metadata_reporting( &mut bytes.as_slice(), DEFAULT_MAX_FRAME_BYTES, |_, _| { seen += 1; Ok(()) }, |_| Ok(()) ) .is_err() ); assert_eq!(seen, 0); } } #[test] fn required_completion_above_reader_limit_fails_closed() { let (submission_id, call_id, entries) = completion(); let frame = Frame::Commit { checkpoint: ToolCompletionCheckpoint { submission_id, call_id, }, entries: Box::new(entries), }; let bytes = frame.encode(DEFAULT_MAX_FRAME_BYTES).unwrap(); assert!(read_frames(&mut bytes.as_slice(), 1).is_err()); } #[test] fn completion_rejects_invalid_members_identities_order_and_byte_limit() { let (submission_id, call_id, entries) = completion(); let checkpoint = ToolCompletionCheckpoint { submission_id, call_id, }; let valid = Frame::Commit { checkpoint, entries: Box::new(entries.clone()), }; let bytes = valid.encode(DEFAULT_MAX_FRAME_BYTES).unwrap(); let payload_length = bytes.len() - HEADER_LEN - BODY_PREFIX_LEN; assert_eq!(valid.encode(payload_length).unwrap(), bytes); assert!(valid.encode(payload_length - 1).is_err()); for (left, right) in [(0, 1), (0, 2), (1, 2)] { let mut invalid = entries.clone(); invalid.swap(left, right); assert!( Frame::Commit { checkpoint, entries: Box::new(invalid) } .encode(DEFAULT_MAX_FRAME_BYTES) .is_err() ); } for index in 0..3 { let mut invalid = entries.clone(); invalid[index].id = EntryId::from_u128(0); assert!( Frame::Commit { checkpoint, entries: Box::new(invalid) } .encode(DEFAULT_MAX_FRAME_BYTES) .is_err() ); } let mut invalid = entries.clone(); invalid[2].content = EntryFrame::new( None, &EntryContent::Message(Message::with_text(Role::User, "wrong role")), ) .unwrap() .content; assert!( Frame::Commit { checkpoint, entries: Box::new(invalid) } .encode(DEFAULT_MAX_FRAME_BYTES) .is_err() ); let mut invalid = entries.clone(); invalid[1].parent = Some(entries[2].id); assert!( Frame::Commit { checkpoint, entries: Box::new(invalid) } .encode(DEFAULT_MAX_FRAME_BYTES) .is_err() ); let mut invalid = checkpoint; invalid.call_id = ToolCallId::new(); assert!( Frame::Commit { checkpoint: invalid, entries: Box::new(entries) } .encode(DEFAULT_MAX_FRAME_BYTES) .is_err() ); } #[test] fn completion_corruption_and_every_torn_prefix_publish_no_member() { let (submission_id, call_id, entries) = completion(); let frame = Frame::Commit { checkpoint: ToolCompletionCheckpoint { submission_id, call_id, }, entries: Box::new(entries), }; let bytes = frame.encode(DEFAULT_MAX_FRAME_BYTES).unwrap(); for length in 1..bytes.len() { let mut seen = 0; visit_metadata_reporting( &mut &bytes[..length], DEFAULT_MAX_FRAME_BYTES, |_, _| { seen += 1; Ok(()) }, |_| Ok(()), ) .unwrap(); assert_eq!(seen, 0, "torn at {length}"); } for index in 0..bytes.len() { let mut corrupt = bytes.clone(); corrupt[index] ^= 1; let mut seen = 0; let result = visit_frames_reporting( &mut corrupt.as_slice(), DEFAULT_MAX_FRAME_BYTES, |_| { seen += 1; true }, |_| true, ); assert!(result.is_err(), "corrupt at {index}"); assert_eq!(seen, 0); } } proptest::proptest! { #[test] fn completion_wire_roundtrip_preserves_typed_members(root in 1u128..=(u128::MAX - 3), call in 1u128..=u128::MAX) { let (_, _, mut entries) = completion(); let submission_id = EntryId::from_u128(root); let call_id = ToolCallId::from_u128(call); // Rebuild the typed evidence rather than filtering arbitrary corrupt bytes. let result = EntryFrame::new(Some(submission_id), &EntryContent::ToolResult { call_id, ok: true, output: "written".into(), }).unwrap(); entries[0] = result; entries[0].id = EntryId::from_u128(root + 1); entries[1] = EntryFrame::new(Some(entries[0].id), &EntryContent::Meta { kind: TOOL_MUTATION_KIND.into(), detail: encode(&ToolMutationMetadata::new(call_id, MutationState::Applied)).unwrap(), }).unwrap(); entries[1].id = EntryId::from_u128(root + 2); let mut message = Message::new(Role::Tool); message.add_block(ContentBlock::tool_result(call_id, true, "written")); entries[2] = EntryFrame::new(Some(entries[1].id), &EntryContent::Message(message)).unwrap(); entries[2].id = EntryId::from_u128(root + 3); let frame = Frame::Commit { checkpoint: ToolCompletionCheckpoint { submission_id, call_id }, entries: Box::new(entries) }; let bytes = frame.encode(DEFAULT_MAX_FRAME_BYTES).unwrap(); let recovered = read_frames(&mut bytes.as_slice(), DEFAULT_MAX_FRAME_BYTES).unwrap(); proptest::prop_assert_eq!(recovered.frames, vec![frame]); } }