//! SMH-SPEC-PLUG0001: two independently loaded sandbox consumers coalesce continuation. #[global_allocator] static ALLOC: smith_alloc::Counting = smith_alloc::Counting; #[path = "fixtures/lifecycle_support.rs"] mod support; #[test] fn compiling_same_named_fixtures_preserves_each_artifact() { let root = std::env::temp_dir().join(format!( "smith-fixture-artifacts-{}", smith::id::SessionId::new() )); let source = include_str!("fixtures/lifecycle.rs"); let first = support::compile_fixture(&root.join("first"), source, "lifecycle-artifact-ownership"); let bytes = std::fs::read(&first).unwrap(); let second = support::compile_fixture( &root.join("second"), &source.replace("\"continue\"", "\"second\""), "lifecycle-artifact-ownership", ); assert_ne!(first, second, "each compilation must own its output path"); assert_eq!(std::fs::read(first).unwrap(), bytes); assert_ne!(std::fs::read(second).unwrap(), bytes); std::fs::remove_dir_all(root).unwrap(); } #[test] fn two_components_ensure_exactly_one_next_request() { use smith::{ id::MessageId, stream::{StopReason, StreamEvent}, }; use smith_harness::runtime::{RuntimeConfig, build_agent}; let root = std::env::temp_dir().join(format!("smith-lifecycle-{}", std::process::id())); std::fs::create_dir_all(&root).unwrap(); support::install_consumers(&root, &root.join("plugins")); let script = ["first", "continued"] .into_iter() .map(|text| { vec![ StreamEvent::text_delta(MessageId::new(), text), StreamEvent::stop(StopReason::EndTurn, None), ] }) .collect(); let mut agent = build_agent(&RuntimeConfig::mock(&root, script)).unwrap(); assert_eq!(agent.run_turn("root").unwrap().text, "continued"); assert!( format!("{:?}", agent.session().projected_messages().unwrap()).contains("effective-root") ); std::fs::remove_dir_all(root).unwrap(); } fn dispatcher(root: &std::path::Path, source: &str) -> smith_harness::wasm::RuntimeToolsDispatcher { use smith_harness::{plugins::registry::PackageRegistry, wasm::PluginEngine}; let artifact = support::compile_fixture(&root.join("build"), source, "lifecycle-boundary-fixture"); let registry = PackageRegistry::at(root.join("plugins")); let engine = PluginEngine::new().unwrap(); support::install( ®istry, &engine, &root.join("package"), "example:decisions", &artifact, ); smith_harness::wasm::runtime_tools_dispatcher( root, smith_ai::auth::AuthStore::at(root.join("auth")), false, None, ) .with_package_registry(registry) } fn root(name: &str) -> std::path::PathBuf { let root = std::env::temp_dir().join(format!("smith-lifecycle-{name}-{}", std::process::id())); std::fs::create_dir_all(&root).unwrap(); root } fn event(round_index: u32) -> smith::lifecycle::LifecycleEvent { smith::lifecycle::LifecycleEvent { root_entry_id: smith::EntryId::from_u128(1), boundary: smith::lifecycle::Boundary::TurnComplete, round_index, last_stop: smith::StopReason::EndTurn, continuation_eligible: true, } } fn failure_source(required: bool) -> String { include_str!("fixtures/lifecycle.rs") .replace("vec![HandlerDeclaration { name: \"continue\".into(), boundary: Boundary::TurnComplete, required_decision: false }]", &format!("vec![HandlerDeclaration {{ name: \"continue\".into(), boundary: Boundary::TurnComplete, required_decision: false }}, HandlerDeclaration {{ name: \"fail\".into(), boundary: Boundary::TurnComplete, required_decision: {required} }}]")) .replace("fn handle(_: String,", "fn handle(name: String,") .replace("Ok(if event.round_index", "if name == \"fail\" {{ return Err(\"private-guest-error\".into()); }} Ok(if event.round_index").replace("{{ return Err", "{ return Err").replace("; }} Ok", "; } Ok") } #[test] fn optional_failure_disables_only_its_handler_for_current_generation() { use smith::lifecycle::{DiagnosticCode, LifecycleAction}; use smith_core::tools::ToolDispatcher; let root = root("optional"); let source = failure_source(false); let mut dispatcher = dispatcher(&root, &source); dispatcher.begin_provider_round().unwrap(); let first = dispatcher .lifecycle(&event(0), &smith::CancelHandle::new()) .unwrap(); assert_eq!(first.actions, vec![LifecycleAction::EnsureContinuation]); assert_eq!(first.diagnostics.len(), 1); assert_eq!(first.diagnostics[0].code, DiagnosticCode::HandlerFailed); assert_eq!(first.diagnostics[0].handler, "fail"); assert!(!first.required_failure); assert!(first.allocated_bytes > 0); let next = dispatcher .lifecycle(&event(0), &smith::CancelHandle::new()) .unwrap(); assert_eq!(next.actions, vec![LifecycleAction::EnsureContinuation]); assert!(next.diagnostics.is_empty()); // A separately published generation does not inherit disablement. let mut replacement = self::dispatcher(&root, &source); replacement.begin_provider_round().unwrap(); assert_eq!( replacement .lifecycle(&event(0), &smith::CancelHandle::new()) .unwrap() .diagnostics .len(), 1 ); std::fs::remove_dir_all(root).unwrap(); } #[test] fn required_failure_discards_prior_handler_actions() { use smith_core::tools::ToolDispatcher; let root = root("required"); let mut dispatcher = dispatcher(&root, &failure_source(true)); dispatcher.begin_provider_round().unwrap(); let batch = dispatcher .lifecycle(&event(0), &smith::CancelHandle::new()) .unwrap(); assert!(batch.required_failure); assert!(batch.actions.is_empty()); assert_eq!(batch.diagnostics.len(), 1); assert_eq!( batch.diagnostics[0].code, smith::lifecycle::DiagnosticCode::RequiredDecisionFailed ); std::fs::remove_dir_all(root).unwrap(); } #[test] fn shared_fuel_exhaustion_disables_optional_handler_without_cancelling_root() { fuel_exhaustion(smith::lifecycle::Boundary::TurnComplete); } #[test] fn settled_cleanup_keeps_the_same_shared_fuel_ceiling() { fuel_exhaustion(smith::lifecycle::Boundary::Settled); } fn fuel_exhaustion(boundary: smith::lifecycle::Boundary) { use smith_core::tools::ToolDispatcher; let root = root("fuel"); let source = include_str!("fixtures/lifecycle.rs") .replace("Boundary::TurnComplete", &format!("Boundary::{boundary:?}")); let mut dispatcher = dispatcher(&root, &source).with_composition_grants( smith_harness::wasm::CompositionGrants::default() .with_execution_limits(1, std::time::Duration::from_secs(30)) .unwrap(), ); dispatcher.begin_provider_round().unwrap(); let cancel = smith::CancelHandle::new(); let event = smith::lifecycle::LifecycleEvent { boundary, ..event(0) }; let batch = dispatcher.lifecycle(&event, &cancel).unwrap(); assert!(!cancel.is_cancelled()); assert!(!batch.required_failure); assert!(batch.actions.is_empty()); assert_eq!(batch.diagnostics.len(), 1); assert_eq!( batch.diagnostics[0].code, smith::lifecycle::DiagnosticCode::BudgetExceeded ); assert!( dispatcher .lifecycle(&event, &cancel) .unwrap() .diagnostics .is_empty() ); std::fs::remove_dir_all(root).unwrap(); } #[test] fn cancellation_action_survives_an_invalid_non_cancel_batch() { use smith_core::tools::ToolDispatcher; let root = root("cancel"); let source = include_str!("fixtures/lifecycle.rs").replace( "vec![Action::EnsureContinuation]", "vec![Action::Cancel, Action::SetPrompt(\"a\".into()), Action::SetPrompt(\"b\".into())]", ); let mut dispatcher = dispatcher(&root, &source); dispatcher.begin_provider_round().unwrap(); let cancel = smith::CancelHandle::new(); assert!(matches!( dispatcher.lifecycle(&event(0), &cancel), Err(smith::SmithError::Cancelled) )); assert!(cancel.is_cancelled()); std::fs::remove_dir_all(root).unwrap(); } #[cfg(unix)] #[test] fn failed_reload_retains_prior_subscriptions_and_disable_set_then_valid_reload_resets_them() { use smith_core::tools::ToolDispatcher; use smith_harness::{ plugin_control::ReloadControl, plugins::registry::PackageRegistry, wasm::PluginEngine, }; let root = root("reload"); let source = failure_source(false); let artifact = support::compile_fixture(&root.join("build"), &source, "lifecycle-reload-fixture"); let registry = PackageRegistry::at(root.join("plugins")); let engine = PluginEngine::new().unwrap(); let package = root.join("package"); support::install(®istry, &engine, &package, "example:decisions", &artifact); registry.link(&engine, &package, &[]).unwrap(); let socket = root.join("private/control.sock"); let control = ReloadControl::bind_at_path(socket.clone()).unwrap(); let mut dispatcher = smith_harness::wasm::runtime_tools_dispatcher( &root, smith_ai::auth::AuthStore::at(root.join("auth")), false, Some(control), ) .with_package_registry(registry); dispatcher.begin_provider_round().unwrap(); let cancel = smith::CancelHandle::new(); assert_eq!( dispatcher .lifecycle(&event(0), &cancel) .unwrap() .diagnostics .len(), 1 ); fn reload(socket: &std::path::Path) { use std::io::{Read, Write}; let mut stream = std::os::unix::net::UnixStream::connect(socket).unwrap(); stream .set_read_timeout(Some(std::time::Duration::from_secs(2))) .unwrap(); stream .set_write_timeout(Some(std::time::Duration::from_secs(2))) .unwrap(); stream.write_all(b"reload\n").unwrap(); let mut response = [0; 3]; stream.read_exact(&mut response).unwrap(); assert_eq!(&response, b"ok\n"); } let invalid = source.replace("name: \"continue\".into()", "name: \"\".into()"); let artifact = support::compile_fixture(&root.join("invalid"), &invalid, "lifecycle-invalid-fixture"); std::fs::copy(artifact, package.join("fixture.wasm")).unwrap(); reload(&socket); dispatcher.begin_provider_round().unwrap(); let retained = dispatcher.lifecycle(&event(0), &cancel).unwrap(); assert_eq!( retained.actions, vec![smith::lifecycle::LifecycleAction::EnsureContinuation] ); assert!(retained.diagnostics.is_empty()); let artifact = support::compile_fixture( &root.join("replacement"), &source, "lifecycle-valid-fixture", ); std::fs::copy(artifact, package.join("fixture.wasm")).unwrap(); reload(&socket); dispatcher.begin_provider_round().unwrap(); let replacement = dispatcher.lifecycle(&event(0), &cancel).unwrap(); assert_eq!( replacement.actions, vec![smith::lifecycle::LifecycleAction::EnsureContinuation] ); assert_eq!(replacement.diagnostics.len(), 1); drop(dispatcher); std::fs::remove_dir_all(root).unwrap(); } #[test] fn lifecycle_tool_policy_cannot_grow_resident_state_past_its_item_bound() { use smith::lifecycle::{LifecycleAction, TOOL_POLICY_ITEMS_MAX, ToolAvailability}; use smith_core::tools::ToolDispatcher; let root = root("policy-bound"); let source = include_str!("fixtures/lifecycle.rs").replace("fn declare_tools() -> Vec {\n vec![]", "fn declare_tools() -> Vec {\n vec![plugin::ToolDeclaration { name: \"controlled\".into(), description: \"controlled fixture\".into(), input_schema_json: \"{}\".into() }]"); let mut policy = smith_harness::wasm::ToolPolicy::default(); for index in 0..TOOL_POLICY_ITEMS_MAX { policy .set( format!("prior:host/tool-{index}"), ToolAvailability::Disabled, ) .unwrap(); } let mut dispatcher = dispatcher(&root, &source).with_tool_policy(policy); dispatcher.begin_provider_round().unwrap(); assert!( dispatcher .validate_lifecycle( &[LifecycleAction::SetToolPolicy(vec![( "example:decisions/controlled".into(), ToolAvailability::Hidden )])], "mock" ) .is_err() ); std::fs::remove_dir_all(root).unwrap(); } #[test] fn allocation_crossing_discards_actions_and_stops_later_handlers_without_cancelling_root() { use smith_core::tools::ToolDispatcher; for (name, first_action) in [ ("allocation-continuation", "Action::EnsureContinuation"), ("allocation-cancel", "Action::Cancel"), ] { let root = root(name); // Second handler would cancel the root if entered after the first crossed the budget. let source = failure_source(false) .replace( "return Err(\"private-guest-error\".into());", "return Ok(vec![Action::Cancel]);", ) .replace( "vec![Action::EnsureContinuation]", &format!("vec![{first_action}]"), ); let mut dispatcher = dispatcher(&root, &source).with_composition_grants( smith_harness::wasm::CompositionGrants::default() .with_host_allocation_limit(1) .unwrap(), ); dispatcher.begin_provider_round().unwrap(); let cancel = smith::CancelHandle::new(); let batch = dispatcher.lifecycle(&event(0), &cancel).unwrap(); assert!(!cancel.is_cancelled()); assert!(!batch.required_failure); assert!(batch.allocated_bytes > 1); assert!(batch.actions.is_empty()); assert_eq!(batch.diagnostics.len(), 2); assert!( batch .diagnostics .iter() .all(|diagnostic| diagnostic.code == smith::lifecycle::DiagnosticCode::BudgetExceeded) ); assert!( dispatcher .lifecycle(&event(0), &cancel) .unwrap() .diagnostics .is_empty() ); std::fs::remove_dir_all(root).unwrap(); } } #[test] fn real_lifecycle_guest_cannot_catch_intent_or_completion_ack_failure_into_root_settlement() { use futures::StreamExt; use smith::{ StreamFn, stream::{StopReason, StreamEvent}, }; use smith_core::{ agent::Agent, session::{EntryContent, Session}, store::create_session, tools::ToolSession, }; use smith_harness::{ plugins::{Capability, NetScope, registry::PackageRegistry}, wasm::PluginEngine, }; use std::{ io::{Read, Write}, net::TcpListener, sync::{ Arc, Mutex, atomic::{AtomicUsize, Ordering}, }, }; for failed_kind in [ smith_core::metadata::lifecycle::EFFECT_INTENT, smith_core::metadata::lifecycle::EFFECT_COMPLETION, ] { let root = root(if failed_kind.ends_with("intent") { "effect-intent-ack" } else { "effect-completion-ack" }); let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let address = listener.local_addr().unwrap(); let origin = format!("http://{address}"); let source = include_str!("fixtures/lifecycle.rs") .replace("Boundary::TurnComplete", "Boundary::PreSettlement") .replace("vec![Action::EnsureContinuation]", &format!(r#"{{ let request = smith::plugin::net_scope::HttpRequest {{ destination: "{origin}".into(), method: "POST".into(), headers: vec![], body: b"fixture".to_vec(), options: smith::plugin::net_scope::RequestOptions {{ timeout_ms: 1000, response_bytes_max: 64 }}, }}; // Catching storage failure must not authorize another HTTP effect or root settlement. let _caught = smith::plugin::net_scope::request(&request); let _again = smith::plugin::net_scope::request(&request); vec![] }}"#)) .replace(" use exports::smith::plugin::lifecycle::*;\n Ok(if", " Ok(if"); let artifact = support::compile_fixture(&root.join("guest"), &source, "lifecycle-ack-fixture"); let package = root.join("package"); std::fs::create_dir_all(&package).unwrap(); std::fs::copy(artifact, package.join("fixture.wasm")).unwrap(); std::fs::write(package.join("plugin.kdl"), "id \"example:ack-boundary\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"fixture.wasm\"\ncapability \"net-scope\"\n").unwrap(); let registry = PackageRegistry::at(root.join("plugins")); registry .install_with_net_scopes( &PluginEngine::new().unwrap(), &package, &[Capability::NetScope], &[NetScope::parse(&origin).unwrap()], ) .unwrap(); let dispatcher = smith_harness::wasm::runtime_tools_dispatcher( &root, smith_ai::auth::AuthStore::at(root.join("auth")), false, None, ) .with_package_registry(registry); let path = root.join("session.smh"); let mut opened = create_session(&path, &Session::new(), smith::Config::default_valid()).unwrap(); let admission = opened .writer .admit( &smith::message::Message::with_text(smith::message::Role::User, "root"), None, None, ) .unwrap(); let session = opened.writer.claim(admission.submission_id).unwrap(); let writer = Arc::new(Mutex::new(opened.writer)); let append = writer.clone(); let completion = writer.clone(); let mut tools = ToolSession::with_persist(root.clone(), session, move |entry, bytes| append.lock().unwrap().append_entry(entry, bytes)) .with_completion_boundary(admission.submission_id, move |frame| { if let smith_core::frame::Frame::Known { entry } = &frame && matches!(EntryContent::decode(&entry.content).unwrap(), EntryContent::Meta { kind, .. } if kind == failed_kind) { return Err(smith::SmithError::Cancelled); } completion.lock().unwrap().append_frame(&frame) }); tools.set_dispatcher(Box::new(dispatcher)); let stream: StreamFn = Arc::new(|_, _| { futures::stream::iter(vec![ Ok(StreamEvent::text_delta(smith::MessageId::new(), "done")), Ok(StreamEvent::stop(StopReason::EndTurn, None)), ]) .boxed() }); let mut agent = Agent::new(stream, tools, "mock"); let probe = listener.try_clone().unwrap(); let server = if failed_kind.ends_with("completion") { Some(std::thread::spawn(move || { let (mut stream, _) = listener.accept().unwrap(); stream .set_read_timeout(Some(std::time::Duration::from_secs(5))) .unwrap(); let mut bytes = [0; 4096]; assert!(stream.read(&mut bytes).unwrap() > 0); stream .write_all( b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok", ) .unwrap(); })) } else { None }; let settlements = Arc::new(AtomicUsize::new(0)); let settled = settlements.clone(); let result = agent.run_admitted(admission.submission_id, move |frame| { settled.fetch_add(1, Ordering::Relaxed); writer.lock().unwrap().append_frame(&frame) }); assert!(result.is_err()); assert_eq!(settlements.load(Ordering::Relaxed), 0); assert!(agent.run_turn("must-not-retry").is_err()); if let Some(server) = server { server.join().unwrap(); } else { probe.set_nonblocking(true).unwrap(); assert_eq!( probe.accept().unwrap_err().kind(), std::io::ErrorKind::WouldBlock, "failed intent acknowledgement must prevent any HTTP" ); } let reader = smith_core::store::SessionReader::open(&path).unwrap(); assert_eq!( reader .work_status( admission.submission_id, smith::Config::default_valid().frame_bytes_max ) .unwrap(), Some(smith_core::store::WorkStatus::Running) ); std::fs::remove_dir_all(root).unwrap(); } }