//! SMH-SPEC-SPEC0001: nested admission, acknowledgement, redaction, and bounds. use super::*; use crate::frame::Frame; use crate::metadata::{NESTED_EFFECTS_MAX, NESTED_INTENT_KIND, NESTED_PAYLOAD_BYTES_MAX}; use crate::session::EntryContent; use smith::message::{Message, Role}; #[test] fn known_applied_mutation_survives_a_later_unknown_nested_effect() { assert_eq!( aggregate_mutation(MutationState::Applied, MutationState::Unknown), MutationState::Applied ); } proptest::proptest! { #[test] fn mutation_aggregation_is_order_independent(left in 0usize..3, right in 0usize..3) { let states = [MutationState::NotApplied, MutationState::Unknown, MutationState::Applied]; proptest::prop_assert_eq!(aggregate_mutation(states[left], states[right]), aggregate_mutation(states[right], states[left])); } #[test] fn mutation_aggregation_is_idempotent(index in 0usize..3) { let state = [MutationState::NotApplied, MutationState::Unknown, MutationState::Applied][index]; proptest::prop_assert_eq!(aggregate_mutation(state, state), state); } } struct CatchingWrites; impl ToolDispatcher for CatchingWrites { fn invoke( &mut self, _: &str, input: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { let _first = effects.invoke("write", input); let second = ToolArguments::from_serializable( &serde_json::json!({"path":"second.txt","content":"never"}), ) .unwrap(); let _second = effects.invoke("write", &second); Ok("guest caught host errors".into()) } } fn root(tools: &mut ToolSession) -> smith::id::EntryId { tools .session .append(EntryContentRef::Message(&Message::with_text( Role::User, "write", ))) .unwrap() .id } #[test] fn nested_completion_failure_poison_survives_guest_catching_error() { let dir = std::env::temp_dir().join(format!( "smith-nested-failure-{}", smith::id::SessionId::new() )); std::fs::create_dir(&dir).unwrap(); let mut tools = ToolSession::new(&dir); let submission = root(&mut tools); tools.set_dispatcher(Box::new(CatchingWrites)); let completions = Arc::new(AtomicUsize::new(0)); let seen = Arc::clone(&completions); let mut tools = tools.with_completion_boundary(submission, move |frame| { assert!( matches!(frame, Frame::NestedCommit { .. }), "outer success must not be attempted" ); seen.fetch_add(1, Ordering::Relaxed); Err(SmithError::Cancelled) }); let input = ToolArguments::from_serializable(&serde_json::json!({"path":"first.txt","content":"once"})) .unwrap(); let error = tools.invoke("write", &input).unwrap_err(); assert!(matches!( error, SmithError::RecordFailed { mutation_state: MutationState::Applied, .. } )); assert_eq!( std::fs::read_to_string(dir.join("first.txt")).unwrap(), "once" ); assert!(!dir.join("second.txt").exists()); assert!(tools.invoke("write", &input).is_err()); assert_eq!(completions.load(Ordering::Relaxed), 1); assert_eq!(tools.session.active_branch().entries().len(), 3); assert!(tools.cancel_handle().is_cancelled()); std::fs::remove_dir_all(dir).unwrap(); } #[test] fn nested_intent_failure_blocks_even_first_dispatch_and_outer_success() { let dir = std::env::temp_dir().join(format!( "smith-nested-intent-{}", smith::id::SessionId::new() )); std::fs::create_dir(&dir).unwrap(); let mut tools = ToolSession::with_persist(&dir, Session::new(), |_, bytes| { if matches!(EntryContent::decode(bytes)?, EntryContent::Meta { kind, .. } if kind == NESTED_INTENT_KIND) { Err(SmithError::Cancelled) } else { Ok(()) } }); let submission = root(&mut tools); tools.set_dispatcher(Box::new(CatchingWrites)); let mut tools = tools.with_completion_boundary(submission, |_| { panic!("no completion may follow uncertain intent") }); let input = ToolArguments::from_serializable( &serde_json::json!({"path":"first.txt","content":"never"}), ) .unwrap(); assert!(tools.invoke("write", &input).is_err()); assert!(!dir.join("first.txt").exists()); assert!(!dir.join("second.txt").exists()); assert_eq!(tools.session.active_branch().entries().len(), 2); std::fs::remove_dir_all(dir).unwrap(); } struct SpilledEvidence; impl ToolDispatcher for SpilledEvidence { fn invoke( &mut self, _: &str, _: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { let evidence = "x".repeat(1024 * 1024); effects.begin_nested("http", &evidence)?; effects.finish_nested(true, MutationState::Applied, &evidence)?; Ok("complete".into()) } } #[test] fn one_mib_nested_input_and_output_complete_without_inline_rejection() { let mut tools = ToolSession::new(std::env::temp_dir()); let submission = root(&mut tools); tools.set_dispatcher(Box::new(SpilledEvidence)); tools.register(smith::tool::ToolMetadata::new("fixture", "large evidence")); let mut tools = tools.with_completion_boundary(submission, |_| Ok(())); assert!( tools .invoke("fixture", &ToolArguments::empty_object()) .unwrap() .ok ); } struct LargePrimitives; impl ToolDispatcher for LargePrimitives { fn invoke( &mut self, _: &str, _: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { let content = "line\n".repeat(16 * 1024); let write = ToolArguments::from_serializable( &serde_json::json!({"path":"large.txt", "content":content}), ) .unwrap(); effects.invoke_redacted("write", &write, str::to_string)?; let read = ToolArguments::from_serializable( &serde_json::json!({"path":"large.txt", "max_bytes":content.len()}), ) .unwrap(); assert_eq!( effects.invoke_redacted("read", &read, str::to_string)?, content ); let process = ToolArguments::from_serializable( &serde_json::json!({"command":"printf '%050000d' 0; printf '%050000d' 0 >&2"}), ) .unwrap(); let output = effects.invoke_redacted("bash", &process, str::to_string)?; assert_eq!(output.bytes().filter(|byte| *byte == b'0').count(), 100000); Ok("complete".into()) } } #[test] fn workspace_arguments_results_and_process_output_share_the_spill_path() { let dir = std::env::temp_dir().join(format!( "smith-primitive-payload-{}", smith::id::SessionId::new() )); std::fs::create_dir(&dir).unwrap(); let mut tools = ToolSession::new(&dir); let submission = root(&mut tools); tools.register(smith::tool::ToolMetadata::new( "fixture", "large primitives", )); tools.set_dispatcher(Box::new(LargePrimitives)); let chunks = Arc::new(std::sync::Mutex::new(Vec::new())); let recorded = Arc::clone(&chunks); let mut tools = tools.with_completion_boundary(submission, move |frame| { if let Frame::NestedPayload { chunk } = frame { recorded.lock().unwrap().push(*chunk); } Ok(()) }); assert!( tools .invoke("fixture", &ToolArguments::empty_object()) .unwrap() .ok ); let chunks = chunks.lock().unwrap(); for (index, phase) in [ (0, crate::frame::NestedPayloadPhase::Input), (1, crate::frame::NestedPayloadPhase::Output), (2, crate::frame::NestedPayloadPhase::Output), ] { let value: Vec<_> = chunks .iter() .filter(|chunk| chunk.index == index && chunk.phase == phase) .flat_map(|chunk| chunk.bytes.iter().copied()) .collect(); assert!(value.len() > crate::metadata::NESTED_EFFECT_BYTES_MAX); assert!(std::str::from_utf8(&value).is_ok()); } std::fs::remove_dir_all(dir).unwrap(); } struct OversizedCompletion; impl ToolDispatcher for OversizedCompletion { fn invoke( &mut self, _: &str, _: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { effects.begin_nested("read", "{}")?; assert!( effects .finish_nested( true, MutationState::NotApplied, &"x".repeat(NESTED_PAYLOAD_BYTES_MAX + 1) ) .is_err() ); let write = ToolArguments::from_serializable( &serde_json::json!({"path":"never.txt","content":"blocked"}), ) .unwrap(); assert!( effects .invoke_redacted("write", &write, str::to_string) .is_err() ); Ok("caught oversized completion".into()) } } #[test] fn oversized_nested_result_poison_blocks_later_dispatch_and_outer_success() { let dir = std::env::temp_dir().join(format!( "smith-nested-output-{}", smith::id::SessionId::new() )); std::fs::create_dir(&dir).unwrap(); let mut tools = ToolSession::new(&dir); let submission = root(&mut tools); tools.set_dispatcher(Box::new(OversizedCompletion)); let mut tools = tools.with_completion_boundary(submission, |_| { panic!("oversized completion cannot persist or settle") }); let input = ToolArguments::from_serializable( &serde_json::json!({"path":"large.txt","max_bytes":NESTED_PAYLOAD_BYTES_MAX + 1}), ) .unwrap(); let error = tools.invoke("read", &input).unwrap_err(); assert!(matches!( error, SmithError::RecordFailed { mutation_state: MutationState::NotApplied, .. } )); assert!(!dir.join("never.txt").exists()); assert_eq!(tools.session.active_branch().entries().len(), 3); std::fs::remove_dir_all(dir).unwrap(); } struct BoundedEffects; impl ToolDispatcher for BoundedEffects { fn invoke( &mut self, _: &str, _: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { assert!( effects .begin_nested("log", &"x".repeat(NESTED_PAYLOAD_BYTES_MAX + 1)) .is_err() ); for index in 0..NESTED_EFFECTS_MAX { effects.begin_nested("log", "redacted")?; assert!(effects.begin_nested("log", "depth two forbidden").is_err()); assert_eq!(effects.next_index, index + 1); effects.finish_nested(true, MutationState::NotApplied, "recorded")?; } assert!(effects.begin_nested("log", "count overflow").is_err()); assert_eq!(effects.stop_reason(), Some(InvocationStop::HostAllocation)); assert!(effects.cancel_handle().is_cancelled()); let write = ToolArguments::from_json(r#"{"path":"never.txt","content":"denied"}"#).unwrap(); assert!(effects.invoke("write", &write).is_err()); Ok("bounded".into()) } } #[test] fn nested_count_depth_and_payload_bounds_reject_before_admission() { let mut tools = ToolSession::new(std::env::temp_dir()); let submission = root(&mut tools); tools.set_dispatcher(Box::new(BoundedEffects)); tools.register(smith::tool::ToolMetadata::new("fixture", "bounded effects")); let mut tools = tools.with_completion_boundary(submission, |_| Ok(())); assert!( tools .invoke("fixture", &ToolArguments::empty_object()) .is_err() ); let intents: Vec<_> = tools .session .active_branch() .entries() .iter() .filter_map(|entry| match tools.session.content(entry).unwrap() { EntryContent::Meta { kind, detail } if kind == NESTED_INTENT_KIND => Some(detail), _ => None, }) .collect(); assert_eq!(intents.len(), usize::from(NESTED_EFFECTS_MAX)); for (index, intent) in intents.iter().enumerate() { assert_eq!( crate::metadata::nested_identity(intent.view()).unwrap().2 as usize, index ); } } struct ComposedWrite; impl ToolDispatcher for ComposedWrite { fn invoke( &mut self, _: &str, input: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { effects.with_child("write", "child arguments", None, |child| { child.invoke("write", input) })?; Err(SmithError::Cancelled) } } #[test] fn child_write_survives_parent_failure_with_explicit_ancestry() { use crate::store::{SessionReader, create_session}; use smith::config::Config; let dir = std::env::temp_dir().join(format!("smith-causal-{}", smith::id::SessionId::new())); std::fs::create_dir(&dir).unwrap(); let path = dir.join("session.smh"); let config = Config::default_valid(); let mut opened = create_session(&path, &Session::new(), config.clone()).unwrap(); let receipt = opened .writer .admit(&Message::with_text(Role::User, "compose"), None, None) .unwrap(); let session = opened.writer.claim(receipt.submission_id).unwrap(); let writer = Arc::new(std::sync::Mutex::new(opened.writer)); let entry_writer = Arc::clone(&writer); let mut tools = ToolSession::with_persist(&dir, session, move |entry, content| { entry_writer.lock().unwrap().append_entry(entry, content) }) .with_completion_boundary(receipt.submission_id, move |frame| { writer.lock().unwrap().append_frame(&frame) }); tools.set_dispatcher(Box::new(ComposedWrite)); let input = ToolArguments::from_serializable( &serde_json::json!({"path":"child.txt","content":"durable"}), ) .unwrap(); let result = tools.invoke("write", &input); assert!(matches!(result, Err(SmithError::Cancelled)), "{result:?}"); assert_eq!( std::fs::read_to_string(dir.join("child.txt")).unwrap(), "durable" ); drop(tools); let reader = SessionReader::open(&path).unwrap(); reader.validate_work(config.frame_bytes_max).unwrap(); let mut nested = Vec::new(); reader .scan(config.frame_bytes_max, |frame| { if let Frame::Known { entry } | Frame::NestedCommit { entry } = frame && let EntryContent::Meta { kind, detail } = EntryContent::decode(&entry.content)? && (kind == crate::metadata::NESTED_INTENT_KIND || kind == crate::metadata::NESTED_COMPLETION_KIND) { nested.push(( entry.id, entry.parent, serde_json::to_value(detail).unwrap(), )); } Ok(()) }) .unwrap(); assert_eq!(nested.len(), 4); assert_eq!( nested[0].2["causal"]["effect_id"], nested[3].2["causal"]["effect_id"] ); assert_eq!( nested[1].2["causal"]["parent"], nested[0].2["causal"]["effect_id"] ); assert_eq!(nested[2].2["causal"], nested[1].2["causal"]); assert_eq!(nested[3].1, Some(nested[2].0)); assert_ne!(nested[3].1, Some(nested[0].0)); std::fs::remove_dir_all(dir).unwrap(); } #[test] #[cfg(target_arch = "x86_64")] fn causal_stack_records_have_bounded_exact_layout() { assert_eq!(std::mem::size_of::(), 52); assert_eq!(std::mem::size_of::(), 80); assert_eq!(std::mem::size_of::>(), 48); } struct RecursiveChildren; impl ToolDispatcher for RecursiveChildren { fn invoke( &mut self, _: &str, _: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { fn descend(effects: &mut ToolEffectContext<'_>, remaining: u16) -> Result { if remaining == 0 { assert!( effects .with_child("write", "", None, |_| panic!( "count bound before child entry" )) .is_err() ); return Ok("bounded".into()); } let parent = effects.invocation_id(); let output = effects.with_child("write", "", None, |child| { assert!(child.invocation_id().is_some()); assert_ne!(child.invocation_id(), parent); descend(child, remaining - 1) })?; assert_eq!(effects.invocation_id(), parent); Ok(output) } descend(effects, NESTED_EFFECTS_MAX) } } #[test] fn synchronous_child_stack_reaches_count_bound_then_unwinds() { let mut tools = ToolSession::new(std::env::temp_dir()); let submission = root(&mut tools); tools.set_dispatcher(Box::new(RecursiveChildren)); tools.register(smith::tool::ToolMetadata::new( "fixture", "recursive children", )); let mut tools = tools.with_completion_boundary(submission, |_| Ok(())); assert!( tools .invoke("fixture", &ToolArguments::empty_object()) .is_err() ); } struct CatchingChildFailure; impl ToolDispatcher for CatchingChildFailure { fn invoke( &mut self, _: &str, input: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { let _caught = effects.with_child("write", "", None, |child| { CatchingWrites.invoke("write", input, child) }); let _caught_again = effects.with_child("write", "", None, |_| panic!("poison forbids child entry")); Ok("guest caught child failure".into()) } } #[test] fn caught_child_recording_failure_is_terminal_with_applied_evidence() { let dir = std::env::temp_dir().join(format!( "smith-causal-poison-{}", smith::id::SessionId::new() )); std::fs::create_dir(&dir).unwrap(); let mut tools = ToolSession::new(&dir); let submission = root(&mut tools); tools.set_dispatcher(Box::new(CatchingChildFailure)); let mut tools = tools.with_completion_boundary(submission, |frame| { if matches!(frame, Frame::Known { .. }) { return Ok(()); } assert!(matches!(frame, Frame::NestedCommit { .. })); Err(SmithError::Cancelled) }); let arguments = ToolArguments::from_serializable(&serde_json::json!({"path":"first.txt","content":"once"})) .unwrap(); assert!(matches!( tools.invoke("write", &arguments), Err(SmithError::RecordFailed { mutation_state: MutationState::Applied, .. }) )); assert_eq!( std::fs::read_to_string(dir.join("first.txt")).unwrap(), "once" ); assert!(!dir.join("second.txt").exists()); assert!(tools.cancel_handle().is_cancelled()); assert!(tools.invoke("write", &arguments).is_err()); std::fs::remove_dir_all(dir).unwrap(); } struct CancellingAfterWrite; impl ToolDispatcher for CancellingAfterWrite { fn invoke( &mut self, _: &str, input: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { effects.invoke("write", input)?; effects.stop(InvocationStop::Cancelled); Ok("guest caught cancellation".into()) } } #[test] fn caught_cancellation_cannot_become_a_model_recoverable_outcome() { let dir = std::env::temp_dir().join(format!( "smith-caught-cancellation-{}", smith::id::SessionId::new() )); std::fs::create_dir(&dir).unwrap(); let mut tools = ToolSession::new(&dir); let submission = root(&mut tools); tools.set_dispatcher(Box::new(CancellingAfterWrite)); let mut tools = tools.with_completion_boundary(submission, |_| Ok(())); let input = ToolArguments::from_serializable( &serde_json::json!({"path":"completed.txt","content":"retained"}), ) .unwrap(); let call_id = ToolCallId::new(); let result = tools.invoke_recorded( call_id, "write", &input, &input, str::to_string, EffectFailure::ReturnOutcome, ); assert!(matches!(result, Err(SmithError::Cancelled)), "{result:?}"); assert_eq!( std::fs::read_to_string(dir.join("completed.txt")).unwrap(), "retained" ); let contents: Vec<_> = tools .session .active_branch() .entries() .iter() .map(|entry| tools.session.content(entry).unwrap()) .collect(); assert!(contents.iter().any(|content| matches!(content, EntryContent::ToolResult { call_id: recorded, ok: false, .. } if *recorded == call_id ))); assert!(tools.invoke("write", &input).is_err()); std::fs::remove_dir_all(dir).unwrap(); } struct StoppingAfterWrite(InvocationStop); impl ToolDispatcher for StoppingAfterWrite { fn invoke( &mut self, _: &str, input: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { effects.invoke("write", input)?; let result = effects.with_child("fixture:child/run", "{}", None, |child| { child.stop(self.0); child.stop(InvocationStop::Sandbox); assert_eq!(child.stop_reason(), Some(self.0)); Ok("caught hard stop".into()) }); assert!(result.is_err()); assert!(effects.invoke("write", input).is_err()); Ok("caught child failure".into()) } } #[test] fn typed_hard_stop_survives_child_catch_and_model_outcome_conversion() { for reason in [ InvocationStop::Deadline, InvocationStop::Fuel, InvocationStop::Memory, InvocationStop::Table, InvocationStop::HostAllocation, InvocationStop::Conversion, InvocationStop::Log, InvocationStop::Output, InvocationStop::Sandbox, ] { let dir = std::env::temp_dir().join(format!("smith-hard-stop-{}", smith::id::SessionId::new())); std::fs::create_dir(&dir).unwrap(); let mut tools = ToolSession::new(&dir); let submission = root(&mut tools); tools.set_dispatcher(Box::new(StoppingAfterWrite(reason))); let mut tools = tools.with_completion_boundary(submission, |_| Ok(())); let input = ToolArguments::from_serializable( &serde_json::json!({"path":"completed.txt","content":"retained"}), ) .unwrap(); let result = tools.invoke_recorded( ToolCallId::new(), "write", &input, &input, str::to_string, EffectFailure::ReturnOutcome, ); assert!(result.is_err(), "{reason:?}: {result:?}"); assert!( !tools.recording_failed, "a hard stop must not fabricate recording uncertainty" ); assert!(tools.cancel_handle().is_cancelled()); assert_eq!( std::fs::read_to_string(dir.join("completed.txt")).unwrap(), "retained" ); assert!(tools.invoke("write", &input).is_err()); std::fs::remove_dir_all(dir).unwrap(); } } struct ScopedWrites; impl ToolDispatcher for ScopedWrites { fn invoke( &mut self, _: &str, _: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { effects.confine_workspace()?; effects.with_workspace_subdirectory("A", |effects| { let write = |path: &str| { ToolArguments::from_serializable( &serde_json::json!({"path":path,"content":"delegated"}), ) .unwrap() }; effects.invoke_redacted("write", &write("allowed.txt"), str::to_string)?; let command = ToolArguments::from_serializable(&serde_json::json!({"command":"printf never"})) .unwrap(); assert!( effects .invoke_redacted("bash", &command, str::to_string) .is_err() ); assert!( effects .invoke_redacted("write", &write("../B/denied.txt"), str::to_string) .is_err() ); assert!( effects .with_workspace_subdirectory("../B", |_| Ok("never".into())) .is_err() ); Ok("narrowed".into()) })?; let caught = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { let _ = effects.with_workspace_subdirectory("A", |_| -> Result { panic!("scope unwind"); }); })); assert!(caught.is_err()); let parent = ToolArguments::from_serializable( &serde_json::json!({"path":"parent.txt","content":"restored"}), ) .unwrap(); effects.invoke_redacted("write", &parent, str::to_string) } } #[test] fn descriptor_scopes_reject_escape_and_restore_parent_after_unwind() { let dir = std::env::temp_dir().join(format!( "smith-workspace-scopes-{}", smith::id::SessionId::new() )); std::fs::create_dir_all(dir.join("A")).unwrap(); std::fs::create_dir_all(dir.join("B")).unwrap(); let mut tools = ToolSession::new(&dir); let submission = root(&mut tools); tools.register(smith::tool::ToolMetadata::new("fixture", "scoped writes")); tools.set_dispatcher(Box::new(ScopedWrites)); let mut tools = tools.with_completion_boundary(submission, |_| Ok(())); assert!( tools .invoke("fixture", &ToolArguments::empty_object()) .unwrap() .ok ); assert_eq!( std::fs::read_to_string(dir.join("A/allowed.txt")).unwrap(), "delegated" ); assert!(!dir.join("B/denied.txt").exists()); assert_eq!( std::fs::read_to_string(dir.join("parent.txt")).unwrap(), "restored" ); assert!(!dir.join("A/parent.txt").exists()); std::fs::remove_dir_all(dir).unwrap(); } #[test] fn invocation_allocation_report_is_a_fixed_resident_snapshot() { assert_eq!(std::mem::size_of::(), 56); } struct AcknowledgedAllocation(Arc); impl InvocationAllocationObserver for AcknowledgedAllocation { fn report(&self) -> Result { let actual_bytes = self.0.load(Ordering::SeqCst) as u64; if actual_bytes == u64::MAX { return Err(SmithError::Cancelled); } Ok(InvocationAllocationReport { threshold_bytes: 100, actual_bytes, cleanup_bytes: 0, excess_bytes: actual_bytes.saturating_sub(100), allocations: 3, stopped_bytes: None, }) } } impl ToolDispatcher for AcknowledgedAllocation { fn invoke( &mut self, _: &str, input: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { assert!( effects .hold_allocation_observer(Box::new(Self(Arc::clone(&self.0)))) .is_none() ); effects.report_allocation(100, 50, 1); effects.invoke("write", input) } } #[test] fn terminal_recording_crossing_preserves_completed_effect_then_persists_causal_stop() { let dir = std::env::temp_dir().join(format!("smith-late-stop-{}", smith::id::SessionId::new())); std::fs::create_dir(&dir).unwrap(); let usage = Arc::new(AtomicUsize::new(50)); let persisted = Arc::new(std::sync::Mutex::new(Vec::new())); let seen = Arc::clone(&persisted); let mut tools = ToolSession::with_persist(&dir, Session::new(), move |entry, bytes| { seen.lock() .unwrap() .push((entry.id, EntryContent::decode(bytes)?)); Ok(()) }); let submission = root(&mut tools); tools.set_dispatcher(Box::new(AcknowledgedAllocation(Arc::clone(&usage)))); let acknowledged = Arc::clone(&usage); let mut tools = tools.with_completion_boundary(submission, move |frame| { if matches!(frame, Frame::Commit { .. }) { acknowledged.store(125, Ordering::SeqCst); } Ok(()) }); let input = ToolArguments::from_serializable( &serde_json::json!({"path":"done.txt","content":"retained"}), ) .unwrap(); let call_id = ToolCallId::new(); let error = tools .invoke_recorded( call_id, "write", &input, &input, str::to_string, EffectFailure::ReturnOutcome, ) .unwrap_err(); assert!(error.to_string().contains("HostAllocation")); assert!(tools.cancel_handle().is_cancelled()); let entries = tools.session.active_branch().entries(); assert!(entries.iter().any(|entry| matches!(tools.session.content(entry).unwrap(), EntryContent::ToolResult { call_id: id, ok: true, .. } if id == call_id))); let recorded = persisted.lock().unwrap(); let (_, EntryContent::Meta { kind, detail }) = recorded.last().unwrap() else { panic!("missing durable stop") }; assert_eq!(kind, "invocation-terminal-stop"); let detail = serde_json::to_value(detail).unwrap(); assert_eq!(detail["call_id"], call_id.to_string()); assert_eq!(detail["submission_id"], submission.to_string()); assert_eq!(detail["reason"], "HostAllocation"); assert_eq!(detail["allocation"]["actual_bytes"], 125); assert_eq!(detail["allocation"]["cleanup_bytes"], 75); drop(recorded); let count = tools.session.active_branch().entries().len(); assert!(tools.invoke("write", &input).is_err()); assert_eq!(tools.session.active_branch().entries().len(), count); assert_eq!( std::fs::read_to_string(dir.join("done.txt")).unwrap(), "retained" ); std::fs::remove_dir_all(dir).unwrap(); } #[test] fn recording_failure_remains_primary_when_allocation_observation_also_fails() { let dir = std::env::temp_dir().join(format!( "smith-poison-observer-{}", smith::id::SessionId::new() )); std::fs::create_dir(&dir).unwrap(); let usage = Arc::new(AtomicUsize::new(50)); let mut tools = ToolSession::new(&dir); let submission = root(&mut tools); tools.set_dispatcher(Box::new(AcknowledgedAllocation(Arc::clone(&usage)))); let mut tools = tools.with_completion_boundary(submission, move |_| { usage.store(usize::MAX, Ordering::SeqCst); Err(tool_error( smith::error::ToolCode::Validation, "injected storage primary", )) }); let input = ToolArguments::from_serializable( &serde_json::json!({"path":"done.txt","content":"retained"}), ) .unwrap(); let error = tools.invoke("write", &input).unwrap_err(); assert!( matches!(error, SmithError::RecordFailed { .. }), "{error:?}" ); assert!( error.to_string().contains("injected storage primary"), "{error}" ); assert!(error.to_string().contains("allocation=")); assert!(tools.cancel_handle().is_cancelled()); std::fs::remove_dir_all(dir).unwrap(); }