//! SMH-SPEC-SPEC0001: atomic completion acknowledgement and dispatch poisoning. use super::*; use crate::frame::Frame; use crate::session::{EntryContent, EntryKind}; use smith::message::{Message, Role}; struct PrimitiveDispatcher; impl ToolDispatcher for PrimitiveDispatcher { fn begin_provider_round(&mut self) -> Result { test_tool_snapshot() } fn invoke( &mut self, name: &str, input: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { effects.invoke(name, input) } } #[test] fn atomic_completion_recording_failure_keeps_intent_without_adopting_partial_results() { let dir = std::env::temp_dir().join(format!( "smith-atomic-completion-failure-{}", std::process::id() )); std::fs::create_dir_all(&dir).unwrap(); let mut tools = ToolSession::new(&dir); tools.set_dispatcher(Box::new(PrimitiveDispatcher)); tools.begin_provider_round().unwrap(); let input = tools .session .append(EntryContentRef::Message(&Message::with_text( Role::User, "write", ))) .unwrap() .id; let commits = Arc::new(AtomicUsize::new(0)); let observed = Arc::clone(&commits); let mut tools = tools.with_completion_boundary(input, move |frame| { if matches!(frame, Frame::NestedCommit { .. }) { return Ok(()); } let Frame::Commit { checkpoint, entries, } = frame else { panic!("expected completion") }; assert_eq!(checkpoint.submission_id, input); assert_eq!(entries.len(), 3); observed.fetch_add(1, Ordering::Relaxed); Err(tool_error( smith::error::ToolCode::Validation, "injected completion recording failure", )) }); let arguments = ToolArguments::from_serializable( &serde_json::json!({"path":"written.txt","content":"once"}), ) .unwrap(); let call_id = ToolCallId::new(); let error = tools .invoke_local(call_id, "write", &arguments, &arguments, str::to_string) .unwrap_err(); assert!(matches!( error, SmithError::RecordFailed { mutation_state: MutationState::Applied, .. } )); assert_eq!( std::fs::read_to_string(dir.join("written.txt")).unwrap(), "once" ); assert_eq!(commits.load(Ordering::Relaxed), 1); assert_eq!(tools.session.active_branch().entries().len(), 4); assert!(matches!( tools.session.active_branch().entries()[1].kind, EntryKind::ToolCall { .. } )); assert_eq!( tools.session.mutation_state(call_id).unwrap(), MutationState::Unknown ); assert!( tools .invoke_local( ToolCallId::new(), "write", &arguments, &arguments, str::to_string ) .is_err() ); assert_eq!(commits.load(Ordering::Relaxed), 1); assert_eq!(tools.session.active_branch().entries().len(), 4); std::fs::remove_dir_all(dir).unwrap(); } #[test] fn admitted_call_without_dispatcher_rejects_before_intent_or_filesystem_effect() { let dir = std::env::temp_dir().join(format!( "smith-atomic-no-dispatcher-{}", smith::id::SessionId::new() )); std::fs::create_dir_all(&dir).unwrap(); let mut tools = ToolSession::new(&dir); let root = tools .session .append(EntryContentRef::Message(&Message::with_text( Role::User, "write", ))) .unwrap() .id; let mut tools = tools.with_completion_boundary(root, |_| Ok(())); let arguments = ToolArguments::from_serializable(&serde_json::json!({"path":"never.txt","content":"bad"})) .unwrap(); assert!( tools .invoke_local( ToolCallId::new(), "write", &arguments, &arguments, str::to_string, ) .is_err() ); assert_eq!(tools.session.active_branch().entries().len(), 1); assert!(!dir.join("never.txt").exists()); std::fs::remove_dir_all(dir).unwrap(); } #[test] fn admitted_call_identity_is_validated_before_filesystem_dispatch() { let dir = std::env::temp_dir().join(format!( "smith-atomic-call-validation-{}", std::process::id() )); std::fs::create_dir_all(&dir).unwrap(); let mut tools = ToolSession::new(&dir); tools.set_dispatcher(Box::new(PrimitiveDispatcher)); tools.begin_provider_round().unwrap(); let root = tools .session .append(EntryContentRef::Message(&Message::with_text( Role::User, "write", ))) .unwrap() .id; let mut tools = tools.with_completion_boundary(root, |_| Ok(())); let arguments = ToolArguments::from_serializable(&serde_json::json!({"path":"never.txt","content":"bad"})) .unwrap(); assert!( tools .invoke_local( ToolCallId::from_u128(0), "write", &arguments, &arguments, str::to_string ) .is_err() ); assert!(!dir.join("never.txt").exists()); let call_id = ToolCallId::new(); let first = ToolArguments::from_serializable(&serde_json::json!({"path":"once.txt","content":"once"})) .unwrap(); tools .invoke_local(call_id, "write", &first, &first, str::to_string) .unwrap(); assert!( tools .invoke_local(call_id, "write", &arguments, &arguments, str::to_string) .is_err() ); assert!(!dir.join("never.txt").exists()); std::fs::remove_dir_all(dir).unwrap(); } #[test] fn admitted_context_rejects_uncheckpointed_nested_effects_before_dispatch() { let dir = std::env::temp_dir().join(format!( "smith-atomic-nested-rejection-{}", std::process::id() )); std::fs::create_dir_all(&dir).unwrap(); let mut tools = ToolSession::new(&dir).with_completion_boundary(smith::id::EntryId::new(), |_| Ok(())); let mut effects = ToolEffectContext::for_operation(&mut tools, "write"); let log = smith::http::PluginLogRecord { plugin_id: "fixture".into(), level: "info".into(), message: "not executed".into(), }; assert!( effects .record_plugin_log(&log) .unwrap_err() .to_string() .contains("requires an outer call") ); let first = ToolArguments::from_serializable(&serde_json::json!({"path":"first.txt","content":"once"})) .unwrap(); let second = ToolArguments::from_serializable( &serde_json::json!({"path":"second.txt","content":"never"}), ) .unwrap(); assert!(effects.invoke("write", &first).is_err()); assert!( effects .invoke("write", &second) .unwrap_err() .to_string() .contains("requires an outer call") ); assert_eq!(effects.mutation_state, MutationState::NotApplied); assert!(!dir.join("first.txt").exists()); assert!(!dir.join("second.txt").exists()); #[cfg(target_arch = "x86_64")] assert_eq!(std::mem::size_of::(), 32); std::fs::remove_dir_all(dir).unwrap(); } #[test] fn atomic_completion_adopts_exactly_one_paired_conversation_result_after_acknowledgement() { let mut tools = ToolSession::new(std::env::temp_dir()); tools.set_dispatcher(Box::new(PrimitiveDispatcher)); tools.begin_provider_round().unwrap(); let input = tools .session .append(EntryContentRef::Message(&Message::with_text( Role::User, "read", ))) .unwrap() .id; let mut tools = tools.with_completion_boundary(input, |frame| { assert!(matches!( frame, Frame::Commit { .. } | Frame::NestedCommit { .. } )); Ok(()) }); let arguments = ToolArguments::from_serializable( &serde_json::json!({"path":"certainly-missing-smith-atomic-file"}), ) .unwrap(); let call_id = ToolCallId::new(); let outcome = tools .invoke_local(call_id, "read", &arguments, &arguments, str::to_string) .unwrap(); assert!(!outcome.ok); assert_eq!(tools.session.active_branch().entries().len(), 7); let results: Vec<_> = tools .session .active_branch() .entries() .iter() .filter_map(|entry| match tools.session.content(entry).unwrap() { EntryContent::Message(message) if message.role == Role::Tool => Some(message), _ => None, }) .collect(); assert_eq!(results.len(), 1); assert_eq!(results[0].blocks.len(), 1); }