repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-core/tests/lifecycle.rs
Raw//! 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<String> {
Ok("result".into())
}
fn lifecycle(
&mut self,
event: &LifecycleEvent,
cancel: &CancelHandle,
) -> Result<LifecycleBatch> {
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<AtomicUsize>,
std::sync::mpsc::Receiver<smith::ProviderRequest>,
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<LifecycleAction>,
commits: Arc<AtomicUsize>,
policy: Arc<std::sync::Mutex<ToolAvailability>>,
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<String> {
Ok(String::new())
}
fn lifecycle(&mut self, event: &LifecycleEvent, _: &CancelHandle) -> Result<LifecycleBatch> {
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::<bool>(),
) {
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::<Vec<_>>();
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::<Vec<_>>();
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::<LifecycleEvent>(), 24);
assert_eq!(std::mem::size_of::<LifecycleAction>(), 32);
assert_eq!(std::mem::size_of::<ContextEdit>(), 56);
assert_eq!(std::mem::size_of::<LifecycleBatch>(), 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<String> {
unreachable!()
}
fn lifecycle(&mut self, event: &LifecycleEvent, _: &CancelHandle) -> Result<LifecycleBatch> {
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::<u16>()) {
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::<bool>(),
) {
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);
}
}