//! SMH-SPEC-SPEC0001: exact completion record layout and codec allocation pins. use smith::error::MutationState; use smith::id::{EntryId, ToolCallId}; use smith::message::{ContentBlock, Message, Role}; use smith::structured::ToolArguments; use smith_alloc::{Counting, Scope, measure}; use smith_core::frame::{Frame, ToolCompletionCheckpoint, read_frames}; use smith_core::metadata::{ToolMutationMetadata, encode}; use smith_core::session::{EntryContent, EntryFrame, TOOL_MUTATION_KIND}; use smith_core::tools::{ToolDispatcher, ToolEffectContext, ToolSession}; fn payload_chunk_codec_layout_and_allocations_are_exact() { use smith_core::frame::{NestedPayloadChunk, NestedPayloadPhase}; #[cfg(target_arch = "x86_64")] { assert_eq!(std::mem::size_of::(), 80); assert_eq!(std::mem::size_of::(), 120); } let frame = Frame::NestedPayload { chunk: Box::new(NestedPayloadChunk { submission_id: EntryId::from_u128(1), call_id: ToolCallId::from_u128(2), effect_id: EntryId::from_u128(3), index: 0, phase: NestedPayloadPhase::Output, ordinal: 0, bytes: vec![b'x'; smith_core::metadata::NESTED_CHUNK_BYTES_MAX], }), }; let (bytes, encoding) = measure(Scope::Session, || frame.encode(128 * 1024).unwrap()); assert_eq!(encoding.allocations, 1); let (recovered, decoding) = measure(Scope::Session, || { read_frames(&mut bytes.as_slice(), 128 * 1024).unwrap() }); assert_eq!(recovered.frames, vec![frame]); assert_eq!(decoding.allocations, 4); } fn nested_completion_codec_allocations_are_exact() { payload_chunk_codec_layout_and_allocations_are_exact(); #[cfg(target_arch = "x86_64")] { assert_eq!( std::mem::size_of::>(), 80 ); assert_eq!( std::mem::size_of::(), 64 ); } let detail = encode(&smith_core::metadata::NestedEffectCompletion { submission_id: EntryId::from_u128(1), call_id: ToolCallId::from_u128(2), index: 0, ok: true, mutation_state: MutationState::Applied, output: "written".to_string(), }) .unwrap(); let frame = Frame::NestedCommit { entry: EntryFrame::new( Some(EntryId::from_u128(3)), &EntryContent::Meta { kind: smith_core::metadata::NESTED_COMPLETION_KIND.into(), detail, }, ) .unwrap(), }; let (bytes, encoding) = measure(Scope::Session, || frame.encode(1024).unwrap()); assert_eq!(encoding.allocations, 3); let (recovered, decoding) = measure(Scope::Session, || { read_frames(&mut bytes.as_slice(), 1024).unwrap() }); assert_eq!(recovered.frames, vec![frame]); assert_eq!(decoding.allocations, 3); } struct PureDispatcher; impl ToolDispatcher for PureDispatcher { fn invoke( &mut self, _: &str, _: &ToolArguments, _: &mut ToolEffectContext<'_>, ) -> smith::error::Result { Ok(String::new()) } } #[global_allocator] static ALLOCATOR: Counting = Counting; #[test] fn completion_codec_allocations_and_layout_are_exact() { 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(); let frame = Frame::Commit { checkpoint: ToolCompletionCheckpoint { submission_id, call_id, }, entries: Box::new([result, evidence, conversation]), }; let (bytes, encoding) = measure(Scope::Session, || frame.encode(1024).unwrap()); assert_eq!(encoding.allocations, 7); let (recovered, decoding) = measure(Scope::Session, || { read_frames(&mut bytes.as_slice(), 1024).unwrap() }); assert_eq!(recovered.frames, vec![frame]); assert_eq!(decoding.allocations, 6); assert_eq!(std::mem::size_of::(), 32); #[cfg(target_arch = "x86_64")] assert_eq!(std::mem::size_of::(), 120); #[cfg(all(target_arch = "x86_64", target_os = "linux"))] assert_eq!(std::mem::size_of::>(), 48); let mut tools = ToolSession::new(std::env::temp_dir()); let submission = tools .session .append(&EntryContent::Message(Message::with_text( Role::User, "input", ))) .unwrap() .id; tools.register(smith::tool::ToolMetadata::new("fixture", "Pure test tool")); tools.set_dispatcher(Box::new(PureDispatcher)); let mut tools = tools.with_completion_boundary(submission, |frame| { assert!(matches!(frame, Frame::Commit { .. })); Ok(()) }); let arguments = ToolArguments::empty_object(); let (outcome, completion) = measure(Scope::Session, || { tools.invoke("fixture", &arguments).unwrap() }); assert!(outcome.ok); assert_eq!(completion.allocations, 24); assert_eq!(tools.session.active_branch().entries().len(), 5); nested_completion_codec_allocations_are_exact(); causal_completion_layout_and_codec_allocations_are_exact(); } fn causal_completion_layout_and_codec_allocations_are_exact() { use smith_core::metadata::{CausalRecord, NestedCausality, NestedEffectCompletion}; assert_eq!(std::mem::size_of::(), 34); let detail = encode(&CausalRecord { causal: NestedCausality { effect_id: EntryId::from_u128(3), parent: Some(EntryId::from_u128(4)), invocation: true, }, record: NestedEffectCompletion { submission_id: EntryId::from_u128(1), call_id: ToolCallId::from_u128(2), index: 0, ok: true, mutation_state: MutationState::NotApplied, output: "child", }, }) .unwrap(); let frame = Frame::NestedCommit { entry: EntryFrame::new( Some(EntryId::from_u128(5)), &EntryContent::Meta { kind: smith_core::metadata::NESTED_COMPLETION_KIND.into(), detail, }, ) .unwrap(), }; let (bytes, encoding) = measure(Scope::Session, || frame.encode(1024).unwrap()); assert_eq!(encoding.allocations, 3); let (decoded, decoding) = measure(Scope::Session, || { read_frames(&mut bytes.as_slice(), 1024).unwrap() }); assert_eq!(decoding.allocations, 3); assert_eq!(decoded.frames, vec![frame]); }