Luigit
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);
    }
}