//! SMH-SPEC-PLUG0001: sole Agent run loop, atomic decisions, queue delivery and stop precedence. //! SMH-SPEC-SPEC0001: effective context, durable acknowledgement and allocation accounting. use futures::StreamExt; use proptest::prelude::*; use smith::{ Result, StreamFn, lifecycle::*, stream::{StopReason, StreamEvent}, tool::CancelHandle, }; use smith_core::{ agent::{Agent, Delivery, QueuedInput}, session::Session, store::create_session, tools::{ToolDispatcher, ToolEffectContext, ToolSession}, }; use std::sync::{ Arc, atomic::{AtomicUsize, Ordering}, }; #[global_allocator] static ALLOC: smith_alloc::Counting = smith_alloc::Counting; struct Decisions { conflict: bool, cancel: bool, boundary: Boundary, } impl ToolDispatcher for Decisions { fn has_lifecycle_handlers(&self, _: smith::lifecycle::Boundary) -> bool { true } fn invoke( &mut self, _: &str, _: &smith::ToolArguments, _: &mut ToolEffectContext<'_>, ) -> Result { Ok("result".into()) } fn lifecycle( &mut self, event: &LifecycleEvent, cancel: &CancelHandle, ) -> Result { if event.round_index != 0 || event.boundary != self.boundary { return Ok(LifecycleBatch::default()); } if self.cancel { self.cancel = false; cancel.cancel(); } let mut actions = vec![ LifecycleAction::EnsureContinuation, LifecycleAction::EnsureContinuation, ]; if self.conflict { actions.extend([ LifecycleAction::SetPrompt("must-not-publish".into()), LifecycleAction::EditContext(vec![ContextEdit { target: event.root_entry_id, replacement: Some(ContextReplacement::Text("must-not-publish".into())), }]), LifecycleAction::SetModel("first".into()), LifecycleAction::SetModel("second".into()), ]); } Ok(LifecycleBatch { actions, ..Default::default() }) } } fn agent( reason: StopReason, conflict: bool, cancel: bool, boundary: Boundary, ) -> ( Agent, Arc, std::sync::mpsc::Receiver, std::path::PathBuf, ) { let root = std::env::temp_dir().join(format!("smith-lifecycle-core-{}", smith::SessionId::new())); std::fs::create_dir_all(&root).unwrap(); let opened = create_session( &root.join("session.smh"), &Session::new(), smith::Config::default_valid(), ) .unwrap(); let mut tools = ToolSession::with_session(root.clone(), opened.session, opened.writer); tools.set_dispatcher(Box::new(Decisions { conflict, cancel, boundary, })); let count = Arc::new(AtomicUsize::new(0)); let counter = count.clone(); let (sender, requests) = std::sync::mpsc::channel(); let stream: StreamFn = Arc::new(move |request, _| { let index = counter.fetch_add(1, Ordering::Relaxed); let _ = sender.send(request); assert!(index < 4, "continuation must be bounded"); futures::stream::iter(vec![ Ok(StreamEvent::text_delta( smith::MessageId::new(), if index == 0 { "first" } else { "next" }, )), Ok(StreamEvent::stop(reason, None)), ]) .boxed() }); (Agent::new(stream, tools, "mock"), count, requests, root) } #[test] fn continuation_does_not_consume_after_turn_input() { let (mut agent, count, requests, root) = agent(StopReason::EndTurn, false, false, Boundary::TurnComplete); agent.queue(QueuedInput { text: "later".into(), delivery: Delivery::AfterTurn, }); assert_eq!(agent.run_turn("root").unwrap().text, "next"); assert_eq!(count.load(Ordering::Relaxed), 2); let seen: Vec<_> = requests.try_iter().collect(); assert!( seen.iter() .all(|request| !format!("{:?}", request.messages).contains("later")) ); assert_eq!(agent.run_queued().unwrap().len(), 1); assert_eq!(count.load(Ordering::Relaxed), 4); std::fs::remove_dir_all(root).unwrap(); } #[test] fn pre_settlement_can_request_one_continuation() { let (mut agent, count, _, root) = agent(StopReason::EndTurn, false, false, Boundary::PreSettlement); assert_eq!(agent.run_turn("root").unwrap().text, "next"); assert_eq!(count.load(Ordering::Relaxed), 2); std::fs::remove_dir_all(root).unwrap(); } #[test] fn rejected_batch_preserves_context_model_and_prompt() { let (mut agent, count, requests, root) = agent(StopReason::EndTurn, true, false, Boundary::TurnComplete); assert_eq!(agent.run_turn("raw-root").unwrap().text, "first"); assert_eq!(count.load(Ordering::Relaxed), 1); assert_eq!(agent.run_turn("second-root").unwrap().text, "next"); let requests: Vec<_> = requests.try_iter().collect(); assert!(requests.iter().all(|request| request.model == "mock" && !format!("{:?}", request.messages).contains("must-not-publish"))); assert!(format!("{:?}", agent.session().projected_messages().unwrap()).contains("raw-root")); std::fs::remove_dir_all(root).unwrap(); } struct RejectedBatch { actions: Vec, commits: Arc, policy: Arc>, rejected_context: String, } impl ToolDispatcher for RejectedBatch { fn has_lifecycle_handlers(&self, _: smith::lifecycle::Boundary) -> bool { true } fn invoke( &mut self, _: &str, _: &smith::ToolArguments, _: &mut ToolEffectContext<'_>, ) -> Result { Ok(String::new()) } fn lifecycle(&mut self, event: &LifecycleEvent, _: &CancelHandle) -> Result { if event.boundary == Boundary::TurnComplete && event.round_index == 0 { let mut actions = self.actions.clone(); actions.push(LifecycleAction::EditContext(vec![ContextEdit { target: event.root_entry_id, replacement: Some(ContextReplacement::Text(format!( "replacement-{}", self.rejected_context ))), }])); Ok(LifecycleBatch { actions, ..Default::default() }) } else { Ok(LifecycleBatch::default()) } } fn validate_lifecycle(&self, _: &[LifecycleAction], _: &str) -> Result<()> { Ok(()) } fn commit_lifecycle(&mut self, actions: &[LifecycleAction]) { if actions.is_empty() { return; } self.commits.fetch_add(1, Ordering::Relaxed); if let Some(LifecycleAction::SetToolPolicy(changes)) = actions .iter() .find(|action| matches!(action, LifecycleAction::SetToolPolicy(_))) && let Some((_, state)) = changes.first() { *self.policy.lock().unwrap() = *state; } } } proptest::proptest! { #![proptest_config(proptest::test_runner::Config { cases: 24, rng_seed: proptest::test_runner::RngSeed::Fixed(0x504c_5547_0001), ..proptest::test_runner::Config::default() })] #[test] fn conflicting_batch_rejects_every_publication( initial_model in "[a-z]{1,8}", initial_prompt in "[a-z ]{1,16}", initial_context in "[a-z ]{1,16}", initial_availability in 0u8..3, rejected_prompt in "[a-z ]{1,16}", rejected_context in "[a-z ]{1,16}", reverse_actions in proptest::prelude::any::(), ) { let initial_availability = match initial_availability { 0 => ToolAvailability::Advertised, 1 => ToolAvailability::Hidden, _ => ToolAvailability::Disabled, }; let changed_availability = match initial_availability { ToolAvailability::Advertised => ToolAvailability::Hidden, ToolAvailability::Hidden => ToolAvailability::Disabled, ToolAvailability::Disabled => ToolAvailability::Advertised, }; let root = std::env::temp_dir().join(format!( "smith-lifecycle-property-{}", smith::SessionId::new() )); std::fs::create_dir_all(&root).unwrap(); let mut session = Session::new(); session.append(&smith_core::session::EntryContent::Message( smith::Message::with_text(smith::Role::System, &initial_prompt), )).unwrap(); let path = root.join("session.smh"); let opened = create_session(&path, &session, smith::Config::default_valid()).unwrap(); let commits = Arc::new(AtomicUsize::new(0)); let policy = Arc::new(std::sync::Mutex::new(initial_availability)); let mut actions = vec![ LifecycleAction::EnsureContinuation, LifecycleAction::SetModel(initial_model.clone()), LifecycleAction::SetModel(format!("{initial_model}-other")), LifecycleAction::SetPrompt(format!("replacement-{rejected_prompt}")), LifecycleAction::SetToolPolicy(vec![("example:property/tool".into(), changed_availability)]), ]; if reverse_actions { actions.reverse(); } let mut tools = ToolSession::with_session(root.clone(), opened.session, opened.writer); tools.set_dispatcher(Box::new(RejectedBatch { actions, commits: Arc::clone(&commits), policy: Arc::clone(&policy), rejected_context: rejected_context.clone(), })); let (sender, requests) = std::sync::mpsc::channel(); let stream: StreamFn = Arc::new(move |request, _| { sender.send(request).unwrap(); futures::stream::iter(vec![ Ok(StreamEvent::text_delta(smith::MessageId::new(), "answer")), Ok(StreamEvent::stop(StopReason::EndTurn, None)), ]).boxed() }); let mut agent = Agent::new(stream, tools, initial_model.clone()); agent.run_turn(&initial_context).unwrap(); let first_requests = requests.try_iter().collect::>(); prop_assert_eq!(first_requests.len(), 1); prop_assert_eq!(&first_requests[0].model, &initial_model); prop_assert!(format!("{:?}", first_requests[0].messages).contains(&initial_prompt), "initial prompt remains effective"); prop_assert_eq!(commits.load(Ordering::Relaxed), 0); prop_assert_eq!(*policy.lock().unwrap(), initial_availability); agent.run_turn("second-root").unwrap(); let second_requests = requests.try_iter().collect::>(); prop_assert_eq!(second_requests.len(), 1); prop_assert_eq!(&second_requests[0].model, &initial_model); let second_messages = format!("{:?}", second_requests[0].messages); prop_assert!(second_messages.contains(&initial_prompt)); let rejected_prompt_value = format!("replacement-{rejected_prompt}"); prop_assert!(!second_messages.contains(&rejected_prompt_value)); prop_assert_eq!(commits.load(Ordering::Relaxed), 0); let projected = agent.session().projected_messages().unwrap(); let projected_text = format!("{projected:?}"); prop_assert!(projected_text.contains(&initial_context)); let rejected_context_value = format!("replacement-{rejected_context}"); prop_assert!(!projected_text.contains(&rejected_context_value)); prop_assert!(projected_text.contains(&initial_prompt)); let reader = smith_core::store::SessionReader::open(&path).unwrap(); let durable = reader.selected_session(smith::Config::default_valid().frame_bytes_max).unwrap(); let durable_text = format!("{:?}", durable.projected_messages().unwrap()); prop_assert!(durable_text.contains(&initial_context)); prop_assert!(!durable_text.contains(&rejected_context_value)); prop_assert!(!durable.active_branch().entries().iter().any(|entry| { matches!(durable.content(entry).unwrap(), smith_core::session::EntryContent::ContextEdit(_)) }), "rejected batch must not persist a context edit"); prop_assert_eq!(commits.load(Ordering::Relaxed), 0); std::fs::remove_dir_all(root).unwrap(); } } #[test] fn cancellation_and_explicit_stop_defeat_continuation_and_keep_queued_input() { for (reason, cancel) in [ (StopReason::EndTurn, true), (StopReason::StopSequence, false), (StopReason::Abort, false), (StopReason::Limit, false), ] { let (mut agent, count, _, root) = agent(reason, false, cancel, Boundary::TurnComplete); agent.queue(QueuedInput { text: "later".into(), delivery: Delivery::AfterTurn, }); let result = agent.run_turn("root"); assert_eq!(result.is_err(), cancel); assert_eq!(count.load(Ordering::Relaxed), 1); agent.renew_cancel_handle(); assert_eq!(agent.run_queued().unwrap().len(), 1); std::fs::remove_dir_all(root).unwrap(); } } #[test] fn between_request_input_is_not_consumed_twice() { let (mut agent, count, requests, root) = agent(StopReason::EndTurn, false, false, Boundary::TurnComplete); agent.queue(QueuedInput { text: "steer-once".into(), delivery: Delivery::BetweenRequests, }); agent.run_turn("root").unwrap(); assert_eq!(count.load(Ordering::Relaxed), 2); for request in requests.try_iter() { assert_eq!( format!("{:?}", request.messages) .matches("steer-once") .count(), 1 ); } assert!(agent.run_queued().unwrap().is_empty()); std::fs::remove_dir_all(root).unwrap(); } #[test] fn action_validation_has_zero_success_allocations() { let actions = vec![ LifecycleAction::SetPrompt("prompt".into()), LifecycleAction::EnsureContinuation, ]; let (_, stats) = smith_alloc::measure(smith_alloc::Scope::Turn, || { validate_actions(&actions).unwrap() }); assert_eq!(stats.allocations, 0); } #[cfg(target_arch = "x86_64")] #[test] fn lifecycle_layouts_are_pinned() { assert_eq!(std::mem::size_of::(), 24); assert_eq!(std::mem::size_of::(), 32); assert_eq!(std::mem::size_of::(), 56); assert_eq!(std::mem::size_of::(), 64); } #[test] fn conflicting_batch_failure_allocation_is_pinned() { let actions = vec![ LifecycleAction::SetPrompt("a".into()), LifecycleAction::SetPrompt("b".into()), ]; let (result, stats) = smith_alloc::measure(smith_alloc::Scope::Turn, || validate_actions(&actions)); assert!(result.is_err()); assert_eq!(stats.allocations, 2); } #[test] fn continuation_ceiling_is_positive_and_never_dispatches_an_extra_request() { let (mut agent, count, _, root) = agent(StopReason::EndTurn, false, false, Boundary::TurnComplete); assert!(agent.set_continuation_round_limit(0).is_err()); agent.set_continuation_round_limit(1).unwrap(); assert!( agent .run_turn("root") .unwrap_err() .to_string() .contains("round limit") ); assert_eq!(count.load(Ordering::Relaxed), 1); std::fs::remove_dir_all(root).unwrap(); } struct PromptDecision; impl ToolDispatcher for PromptDecision { fn has_lifecycle_handlers(&self, _: smith::lifecycle::Boundary) -> bool { true } fn invoke( &mut self, _: &str, _: &smith::ToolArguments, _: &mut ToolEffectContext<'_>, ) -> Result { unreachable!() } fn lifecycle(&mut self, event: &LifecycleEvent, _: &CancelHandle) -> Result { Ok(LifecycleBatch { actions: if event.round_index == 0 && event.boundary == Boundary::TurnComplete { vec![ LifecycleAction::EnsureContinuation, LifecycleAction::SetPrompt("private-value".into()), ] } else { vec![] }, ..Default::default() }) } } #[test] fn accepted_prompt_replaces_prior_system_context_only_after_secret_safe_durable_record() { use smith_core::{session::EntryContent, store::SessionReader}; let root = std::env::temp_dir().join(format!( "smith-lifecycle-prompt-{}", smith::SessionId::new() )); std::fs::create_dir_all(&root).unwrap(); let mut session = Session::new(); session .append(&EntryContent::Message(smith::Message::with_text( smith::Role::System, "old-system", ))) .unwrap(); let path = root.join("session.smh"); let opened = create_session(&path, &session, smith::Config::default_valid()).unwrap(); let mut tools = ToolSession::with_session(root.clone(), opened.session, opened.writer); tools.set_dispatcher(Box::new(PromptDecision)); let count = Arc::new(AtomicUsize::new(0)); let counter = count.clone(); let stream: StreamFn = Arc::new(move |request, _| { let index = counter.fetch_add(1, Ordering::Relaxed); if index == 1 { let durable = SessionReader::open(&path) .unwrap() .selected_session(smith::Config::default_valid().frame_bytes_max) .unwrap(); let records: Vec<_> = durable .active_branch() .entries() .iter() .filter_map(|entry| match durable.content(entry).unwrap() { EntryContent::Meta { kind, detail } if kind == "lifecycle_decision" => { Some(detail) } _ => None, }) .collect(); assert_eq!(records.len(), 1); let facts = format!("{records:?}"); assert!(facts.contains("{{secret:fixture}}")); assert!(!facts.contains("private-value")); let systems: Vec<_> = request .messages .iter() .filter(|message| message.role == smith::Role::System) .collect(); assert_eq!(systems.len(), 1); assert_eq!( systems[0].blocks, smith::Message::with_text(smith::Role::System, "{{secret:fixture}}").blocks ); } futures::stream::iter(vec![ Ok(StreamEvent::text_delta(smith::MessageId::new(), "response")), Ok(StreamEvent::stop(StopReason::EndTurn, None)), ]) .boxed() }); let mut agent = Agent::new(stream, tools, "mock"); agent.secrets_mut().register("fixture", "private-value"); agent.run_turn("root").unwrap(); assert_eq!(count.load(Ordering::Relaxed), 2); assert!(format!("{:?}", agent.session().projected_messages().unwrap()).contains("old-system")); std::fs::remove_dir_all(root).unwrap(); } #[test] fn lifecycle_effect_metadata_rejects_missing_typed_ownership() { let empty = smith::structured::StructuredData::from_json("{}").unwrap(); for kind in [ "lifecycle-invocation-intent", "lifecycle-effect-intent", "lifecycle-effect-completion", "lifecycle-invocation-completion", ] { assert!( smith_core::metadata::validate(kind, empty.view()).is_err(), "{kind} must validate ownership" ); } } proptest::proptest! { #[test] fn lifecycle_ordinal_validation_matches_the_fixed_count_bound(ordinal in proptest::prelude::any::()) { let detail = smith::structured::StructuredData::from_serializable(&smith_core::metadata::lifecycle::EffectIntent { root_entry_id: smith::EntryId::from_u128(1), invocation_id: smith::EntryId::from_u128(2), effect_id: smith::EntryId::from_u128(3), ordinal, operation: "http", input: "{}", }).unwrap(); proptest::prop_assert_eq!(smith_core::metadata::validate(smith_core::metadata::lifecycle::EFFECT_INTENT, detail.view()).is_ok(), ordinal < smith_core::metadata::NESTED_EFFECTS_MAX); } } proptest::proptest! { #[test] fn notification_queue_intent_roundtrips_original_delivery_and_identity( root in 1u128..u128::MAX, submission in 1u128..u128::MAX, between in proptest::prelude::any::(), ) { let intent = smith_core::control::NotificationAdmission { source: smith_core::control::AdmissionSource::Rpc, notifying_root: smith::EntryId::from_u128(root), submission_id: smith::EntryId::from_u128(submission), delivery: if between { Delivery::BetweenRequests } else { Delivery::AfterTurn }, }; let encoded = smith_core::metadata::encode(&intent).unwrap(); let decoded = smith_core::metadata::notification_admission(encoded.view()).unwrap(); proptest::prop_assert_eq!(decoded, intent); } }