//! Public registered provider consumer (`SMH-SPEC-SPEC0001`, `SMH-SPEC-PLUG0001`). #[global_allocator] static ALLOC: smith_alloc::Counting = smith_alloc::Counting; use smith_harness::plugins::{Capability, PluginManifest}; use smith_harness::protocol::{ ProtocolComponent, ProtocolConnection, ProtocolConnectionConfig, registered_protocol_transport, }; use smith_harness::wasm::bindings::exports::smith::plugin::provider::{ CatalogModel, CatalogSnapshot, CatalogSource, ModelCapabilities, ProviderSettings, SettingsProvenance, }; use smith_harness::wasm::{PluginEngine, PluginGeneration, PluginRegistry}; use std::{ path::{Path, PathBuf}, time::Duration, }; fn fixture(root: &Path) -> PathBuf { compile_fixture( root, include_str!("fixtures/registered-provider.rs"), "registered-provider-fixture", ) } fn compile_fixture(root: &Path, source: &str, name: &str) -> PathBuf { std::fs::create_dir_all(root.join("wit")).unwrap(); std::fs::write( root.join("wit/smith-plugin.wit"), include_str!("../../wit/smith-plugin.wit"), ) .unwrap(); std::fs::write(root.join("lib.rs"), source).unwrap(); std::fs::write( root.join("Cargo.toml"), format!( r#"[package] name = "{name}" version = "0.0.0" edition = "2024" [lib] path = "lib.rs" crate-type = ["cdylib"] [dependencies] wit-bindgen = {{ version = "=0.62.0", default-features = false, features = ["macros"] }} [workspace] "# ), ) .unwrap(); let target = Path::new(env!("CARGO_MANIFEST_DIR")).join("../target"); for args in [ vec!["generate-lockfile", "--offline"], vec![ "build", "--offline", "--locked", "--target", "wasm32-wasip2", ], ] { assert!(std::process::Command::new("cargo").args(args).current_dir(root).env_remove("CARGO_ENCODED_RUSTFLAGS").env("RUSTFLAGS", "-C target-cpu=generic -C link-arg=--initial-memory=2097152 -C link-arg=--max-memory=2097152").env("CARGO_TARGET_DIR", &target).env("XDG_CONFIG_HOME", root.join("config")).status().unwrap().success()); } target.join(format!( "wasm32-wasip2/debug/{}.wasm", name.replace('-', "_") )) } fn generation(engine: &PluginEngine, artifact: &Path, id: &str) -> PluginGeneration { let manifest = PluginManifest::parse(&format!("id \"{id}\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"fixture.wasm\"\ncapability \"net-scope\"\ncapability \"secret-proxy\"")).unwrap(); PluginGeneration::load( engine, manifest, artifact, &[Capability::NetScope, Capability::SecretProxy], ) .unwrap() } fn config( root: &Path, endpoint: String, records: smith::provider::RecordSink, ) -> ProtocolConnectionConfig { ProtocolConnectionConfig { connection_id: "fixture-host", protocol: ProtocolComponent::Registered, artifact: None, endpoint, template_url: "https://fixture.invalid/infer", credential_header: "Authorization", credential_prefix: "Bearer ", static_headers: &[], connection: ProtocolConnection::Api, request_path: "/authorized".into(), credential: smith_ai::auth::CredentialReference::explicit("isolated-secret").into(), auth_store: smith_ai::auth::AuthStore::at(root), executor: smith_harness::http::default_executor(), records, intent_admission_timeout: Duration::from_secs(5), settings: ProviderSettings { include_usage: true, subscription: false, provenance: SettingsProvenance::Explicit, }, catalog: CatalogSnapshot { generation: 41, source: CatalogSource::Cache, models: vec![CatalogModel { id: "fixture-model".into(), capabilities: ModelCapabilities { output_tokens_max: 16, tool_use: false, thinking: false, }, }], }, } } #[test] fn registered_component_runs_real_agent_with_frozen_identity_and_durable_effects() { use smith_core::{ agent::Agent, store::{SessionReader, open_session}, tools::ToolSession, }; use std::io::{Read, Write}; let root = std::env::temp_dir().join(format!("smith-registered-provider-{}", std::process::id())); std::fs::create_dir_all(&root).unwrap(); let built = fixture(&root); let artifact = root.join("fixture.wasm"); std::fs::copy(&built, &artifact).unwrap(); let hash = smith::sha256::digest_hex(&std::fs::read(&artifact).unwrap()); let engine = PluginEngine::new().unwrap(); let mut registry = PluginRegistry::new(); registry .publish_all(vec![ generation(&engine, &artifact, "example:custom"), generation(&engine, &artifact, "example:other"), ]) .unwrap(); // Publication freezes the code before consumer selection, not merely dispatch. std::fs::write(&artifact, b"replaced after publication").unwrap(); let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); let endpoint = format!("http://{}", listener.local_addr().unwrap()); let (records, drain) = smith::provider::record_channel(); let cfg = config(&root, endpoint, records); let stream = registered_protocol_transport( ®istry, "example:custom/custom", "example:custom/fixture-model", "example:custom/fixture-key", cfg.clone(), ) .unwrap(); assert!( registered_protocol_transport( ®istry, "custom", "fixture-model", "fixture-key", cfg.clone() ) .err() .unwrap() .to_string() .contains("ambiguous") ); for (provider, model, source) in [ ("missing", "fixture-model", "fixture-key"), ( "example:custom/custom", "example:other/fixture-model", "example:custom/fixture-key", ), ( "example:custom/custom", "example:custom/fixture-model", "example:other/fixture-key", ), ] { assert!( registered_protocol_transport(®istry, provider, model, source, cfg.clone()).is_err() ); } let mut missing_catalog = cfg.clone(); missing_catalog.catalog.models.clear(); assert!( registered_protocol_transport( ®istry, "example:custom/custom", "example:custom/fixture-model", "example:custom/fixture-key", missing_catalog ) .is_err() ); use futures::StreamExt; let request = smith::provider::ProviderRequest::new("fixture-model", vec![]); let mut unknown = request.clone(); unknown.model = "not-registered".into(); let tools = request .clone() .with_tools(vec![smith::tool::ToolMetadata::new("read", "host tool")]); let thinking = request .clone() .with_params(smith::provider::ProviderParams { thinking: true, ..Default::default() }); let oversized = request .clone() .with_params(smith::provider::ProviderParams { output_tokens_max: Some(17), ..Default::default() }); for rejected in [unknown, tools, thinking, oversized] { let items = futures::executor::block_on( stream(rejected, smith::tool::CancelHandle::new()).collect::>(), ); assert_eq!(items.len(), 1); assert!(items[0].is_err()); } for case in ["template", "origin", "binding", "artifact"] { let mut denied = cfg.clone(); match case { "template" => denied.template_url = "https://unapproved.invalid/", "origin" => denied.endpoint = "http://unapproved.invalid".into(), "binding" => denied.protocol = ProtocolComponent::Anthropic, _ => denied.artifact = Some(artifact.clone()), } let selected = registered_protocol_transport( ®istry, "example:custom/custom", "example:custom/fixture-model", "example:custom/fixture-key", denied, ); match selected { Err(_) => {} Ok(selected) => { let items = futures::executor::block_on( selected(request.clone(), smith::tool::CancelHandle::new()).collect::>(), ); assert_eq!(items.len(), 1); assert!(items[0].is_err()); } } } let ungranted = PluginManifest::parse("id \"example:ungranted\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"fixture.wasm\"\ncapability \"net-scope\"\ncapability \"secret-proxy\"").unwrap(); let error = PluginGeneration::load(&engine, ungranted, &artifact, &[Capability::NetScope]) .err() .unwrap(); assert!(error.to_string().contains("missing grant secret-proxy")); assert_eq!( drain.try_iter().count(), 0, "rejected requests must not admit HTTP intent" ); listener.set_nonblocking(true).unwrap(); assert_eq!( listener.accept().unwrap_err().kind(), std::io::ErrorKind::WouldBlock ); listener.set_nonblocking(false).unwrap(); let (finished, completion) = std::sync::mpsc::sync_channel(1); // Selection remains pinned even when the registry itself is dropped. drop(registry); let server = std::thread::spawn(move || { let (mut socket, _) = listener.accept().unwrap(); socket .set_write_timeout(Some(Duration::from_secs(10))) .unwrap(); socket .set_read_timeout(Some(Duration::from_secs(10))) .unwrap(); let mut bytes = Vec::new(); let mut buffer = [0; 1024]; while !bytes.ends_with(b"custom-wire-request") { let count = socket.read(&mut buffer).unwrap(); assert!(count > 0); bytes.extend_from_slice(&buffer[..count]); } let request = String::from_utf8(bytes).unwrap(); assert!(request.starts_with("POST /authorized HTTP/1.1")); assert!( request .to_ascii_lowercase() .contains("authorization: bearer isolated-secret") ); let body = "custom codec: isolated-secret"; write!( socket, "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len() ) .unwrap(); finished.send(()).unwrap(); }); let path = root.join("session.smh"); let opened = open_session(&path, smith::config::Config::default_valid()).unwrap(); let tools = ToolSession::with_session(&root, opened.session, opened.writer); let mut agent = Agent::with_provider_records(stream, tools, "fixture-model", Some(drain)); let outcome = agent.run_turn("use registered codec").unwrap(); assert_eq!(outcome.text, "custom codec: {{secret:connection-api-key}}"); assert_eq!(outcome.reason, smith::stream::StopReason::EndTurn); assert!(!format!("{outcome:?}").contains("isolated-secret")); completion.recv_timeout(Duration::from_secs(15)).unwrap(); server.join().unwrap(); drop(agent); let reader = SessionReader::open(&path).unwrap(); let mut provenances = Vec::new(); let mut effects = 0; reader .scan( smith::config::Config::default_valid().frame_bytes_max, |frame| { if let smith_core::frame::Frame::Known { entry } = frame && let smith_core::session::EntryContent::Meta { kind, detail } = smith_core::session::EntryContent::decode(&entry.content)? { if kind == smith_core::session::PROVIDER_DISPATCH_PROVENANCE_KIND { provenances.push(serde_json::to_value(detail).unwrap()); } if kind == smith_core::session::PROVIDER_HTTP_KIND { effects += 1; } } Ok(()) }, ) .unwrap(); assert_eq!(provenances.len(), 1); assert_eq!(provenances[0]["protocol_component_sha256"], hash); assert_eq!( provenances[0]["registration_binding"], serde_json::json!({ "provider_id": "example:custom/custom", "model_id": "example:custom/fixture-model", "credential_source_id": "example:custom/fixture-key" }) ); assert_eq!(effects, 2); assert!(!String::from_utf8_lossy(&std::fs::read(&path).unwrap()).contains("isolated-secret")); std::fs::remove_dir_all(root).unwrap(); } #[test] fn invalid_protocol_candidate_is_rejected_before_publication() { let root = std::env::temp_dir().join(format!( "smith-invalid-protocol-candidate-{}", std::process::id() )); std::fs::create_dir_all(&root).unwrap(); let artifact = root.join("invalid.wasm"); std::fs::write(&artifact, b"invalid candidate").unwrap(); let (records, _drain) = smith::provider::record_channel(); let mut connection = config(&root, "http://127.0.0.1:1".into(), records); connection.protocol = ProtocolComponent::OpenAiCompatible; connection.artifact = Some(artifact); assert!(smith_harness::protocol::protocol_transport(connection).is_err()); std::fs::remove_dir_all(root).unwrap(); } #[cfg(unix)] #[test] fn registered_round_keeps_codec_and_whole_tool_batch_then_reloads_atomically() { coherent_round(true); coherent_round(false); } #[cfg(unix)] fn coherent_round(registered: bool) { use smith_core::{ agent::Agent, store::{SessionReader, open_session}, tools::{ToolDispatcher, ToolSession}, }; use smith_harness::{ plugin_control::ReloadControl, plugins::registry::PackageRegistry, wasm::runtime_tools_dispatcher, }; use std::io::{Read, Write}; let root = std::env::temp_dir().join(format!( "smith-coherent-round-{}-{registered}", std::process::id() )); std::fs::create_dir_all(&root).unwrap(); let package = root.join("package"); std::fs::create_dir_all(&package).unwrap(); let source = include_str!("fixtures/coherent-provider.rs"); let first = compile_fixture(&root.join("first"), source, "coherent-provider-fixture"); let artifact = package.join("fixture.wasm"); std::fs::copy(first, &artifact).unwrap(); let first_hash = smith::sha256::digest_hex(&std::fs::read(&artifact).unwrap()); let second = compile_fixture( &root.join("second"), &source.replace("\"v1\"", "\"v2\""), "coherent-provider-fixture", ); let replacement = root.join("replacement.wasm"); std::fs::copy(second, &replacement).unwrap(); let second_hash = smith::sha256::digest_hex(&std::fs::read(&replacement).unwrap()); let invalid = compile_fixture( &root.join("invalid"), &source.replace("\"v1\"", "\"v3\"").replace( "Ok(settings)", "Ok(ProviderSettings { include_usage: false, ..settings })", ), "coherent-provider-fixture", ); let invalid_replacement = root.join("invalid-replacement.wasm"); std::fs::copy(invalid, &invalid_replacement).unwrap(); assert_ne!(first_hash, second_hash); std::fs::write(package.join("plugin.kdl"), "id \"example:coherent\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"fixture.wasm\"\ncapability \"net-scope\"\ncapability \"secret-proxy\"").unwrap(); let engine = PluginEngine::new().unwrap(); let packages = PackageRegistry::at(root.join("registry")); packages .link( &engine, &package, &[Capability::NetScope, Capability::SecretProxy], ) .unwrap(); use std::os::unix::fs::PermissionsExt; std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).unwrap(); let control_path = root.join("control.sock"); let control = ReloadControl::bind_at_path(control_path.clone()).unwrap(); let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); let endpoint = format!("http://{}", listener.local_addr().unwrap()); let (records, drain) = smith::provider::record_channel(); let mut connection = config(&root.join("auth"), endpoint, records); connection.catalog.models[0].capabilities.tool_use = true; let dispatcher = runtime_tools_dispatcher(&root, connection.auth_store.clone(), false, Some(control)) .with_package_registry(packages); let (mut dispatcher, stream) = if registered { dispatcher.with_registered_protocol( connection, "example:coherent/custom".into(), "example:coherent/fixture-model".into(), "example:coherent/fixture-key".into(), ) } else { connection.protocol = ProtocolComponent::OpenAiCompatible; dispatcher.with_protocol(connection) }; dispatcher.begin_provider_round().unwrap(); // Neither transport nor tools may rediscover this raw path before reload. std::fs::write(&artifact, b"swapped after publication").unwrap(); let (sent, finished) = std::sync::mpsc::sync_channel(1); let server = std::thread::spawn(move || { for index in 0..3 { let (mut socket, _) = listener.accept().unwrap(); socket .set_read_timeout(Some(Duration::from_secs(15))) .unwrap(); socket .set_write_timeout(Some(Duration::from_secs(15))) .unwrap(); let mut bytes = Vec::new(); let mut buffer = [0; 4096]; loop { let count = socket.read(&mut buffer).unwrap(); assert!(count > 0); bytes.extend_from_slice(&buffer[..count]); if let Some(split) = bytes.windows(4).position(|part| part == b"\r\n\r\n") { let header = String::from_utf8_lossy(&bytes[..split]); let length = header .lines() .find_map(|line| { let (key, value) = line.split_once(':')?; key.eq_ignore_ascii_case("content-length") .then(|| value.trim().parse::().unwrap()) }) .unwrap(); if bytes.len() >= split + 4 + length { break; } } } let wire = String::from_utf8(bytes).unwrap(); if index == 0 { assert!(wire.contains("v1|v1-definition|")); std::fs::copy(&replacement, &artifact).unwrap(); } else { assert!(wire.contains("v2|v2-definition|"), "{wire}"); assert!(wire.contains("v1-handler"), "{wire}"); if index == 1 { // A single invalid replacement must retain codec + tool set. std::fs::copy(&invalid_replacement, &artifact).unwrap(); } } if index < 2 { let mut control = std::os::unix::net::UnixStream::connect(&control_path).unwrap(); control .set_read_timeout(Some(Duration::from_secs(5))) .unwrap(); control .set_write_timeout(Some(Duration::from_secs(5))) .unwrap(); control.write_all(b"reload\n").unwrap(); let mut reply = [0; 3]; control.read_exact(&mut reply).unwrap(); assert_eq!(&reply, b"ok\n"); } let body = if index == 0 { "tool" } else { "done" }; write!( socket, "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len() ) .unwrap(); } sent.send(()).unwrap(); }); let path = root.join("session.smh"); let opened = open_session(&path, smith::config::Config::default_valid()).unwrap(); let mut tools = ToolSession::with_session(&root, opened.session, opened.writer); tools.set_dispatcher(Box::new(dispatcher)); let mut agent = Agent::with_provider_records(stream, tools, "fixture-model", Some(drain)); assert_eq!( agent.run_turn("reload while streaming").unwrap().text, "v2:done" ); assert_eq!( agent.run_turn("invalid replacement").unwrap().text, "v2:done" ); finished.recv_timeout(Duration::from_secs(20)).unwrap(); server.join().unwrap(); drop(agent); let reader = SessionReader::open(&path).unwrap(); let mut hashes = Vec::new(); reader .scan( smith::config::Config::default_valid().frame_bytes_max, |frame| { if let smith_core::frame::Frame::Known { entry } = frame && let smith_core::session::EntryContent::Meta { kind, detail } = smith_core::session::EntryContent::decode(&entry.content)? && kind == smith_core::session::PROVIDER_DISPATCH_PROVENANCE_KIND { hashes.push( serde_json::to_value(detail).unwrap()["protocol_component_sha256"] .as_str() .unwrap() .to_string(), ); } Ok(()) }, ) .unwrap(); assert_eq!(hashes, [first_hash, second_hash.clone(), second_hash]); let durable = String::from_utf8_lossy(&std::fs::read(&path).unwrap()).into_owned(); assert!(durable.contains("v1-handler")); assert!(!durable.contains("v2-handler")); std::fs::remove_dir_all(root).unwrap(); } #[test] fn round_worker_queues_intent_before_return_and_denial_never_starts_http() { use futures::StreamExt; use smith_core::tools::ToolDispatcher; let root = std::env::temp_dir().join(format!("smith-round-denied-{}", std::process::id())); std::fs::create_dir_all(&root).unwrap(); let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); let (records, drain) = smith::provider::record_channel(); let mut connection = config( &root, format!("http://{}", listener.local_addr().unwrap()), records, ); connection.protocol = ProtocolComponent::OpenAiCompatible; connection.template_url = "https://protocol.invalid/chat/completions"; let dispatcher = smith_harness::wasm::runtime_tools_dispatcher( &root, connection.auth_store.clone(), false, None, ) .with_package_registry(smith_harness::plugins::registry::PackageRegistry::at( root.join("registry"), )); let (mut dispatcher, stream) = dispatcher.with_protocol(connection); dispatcher.begin_provider_round().unwrap(); // A preparation error has no end_provider_round callback. The next request // must still use a valid pin, not a stuck lease or abandoned generation. let bad = stream( smith::provider::ProviderRequest::new("missing", vec![]), smith::tool::CancelHandle::new(), ); assert!(futures::executor::block_on(bad.collect::>())[0].is_err()); for _ in 0..2 { dispatcher.begin_provider_round().unwrap(); let response = stream( smith::provider::ProviderRequest::new("fixture-model", vec![]), smith::tool::CancelHandle::new(), ); let intents: Vec<_> = drain.try_iter().collect(); assert_eq!( intents.len(), 1, "initial intent must exist before stream consumption" ); intents .into_iter() .next() .unwrap() .acknowledge(Err(smith::error::SmithError::Config { field: "fixture".into(), message: "denied durable admission".into(), })); let items = futures::executor::block_on(response.collect::>()); assert!(items.iter().any(Result::is_err)); assert_eq!( drain.try_iter().count(), 1, "denied exchange records its outcome" ); } let cancel = smith::tool::CancelHandle::new(); let response = stream( smith::provider::ProviderRequest::new("fixture-model", vec![]), cancel.clone(), ); let intent = drain.try_iter().next().unwrap(); cancel.cancel(); intent.acknowledge(Ok(())); let items = futures::executor::block_on(response.collect::>()); assert!(items.iter().any(Result::is_err)); assert_eq!(drain.try_iter().count(), 1); listener.set_nonblocking(true).unwrap(); assert_eq!( listener.accept().unwrap_err().kind(), std::io::ErrorKind::WouldBlock ); std::fs::remove_dir_all(root).unwrap(); } #[cfg(unix)] #[test] fn nested_public_agent_pins_reload_and_stops_after_late_recording_crossing() { use futures::StreamExt; use smith_core::{ agent::Agent, session::{EntryContent, EntryFrame}, tools::{ToolDispatcher, ToolSession}, }; use smith_harness::{ plugin_control::ReloadControl, plugins::registry::PackageRegistry, storage::StorageWorker, wasm::{CompositionGrants, ToolPolicy, runtime_tools_dispatcher}, }; use std::{ io::{Read, Write}, sync::{ Arc, atomic::{AtomicUsize, Ordering}, }, }; let root = std::env::temp_dir().join(format!( "smith-nested-reload-{}", smith::id::SessionId::new() )); std::fs::create_dir_all(root.join("A")).unwrap(); use std::os::unix::fs::PermissionsExt; std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).unwrap(); let source = include_str!("fixtures/composition.rs").replace("WIT_PATH", "wit/smith-plugin.wit"); let first = compile_fixture( &root.join("first"), &source.replace("child committed", "v1 child committed"), "nested-reload-fixture", ); let old = root.join("old.wasm"); std::fs::copy(first, &old).unwrap(); let second = compile_fixture( &root.join("second"), &source.replace("child committed", "v2 child committed"), "nested-reload-fixture", ); let replacement = root.join("new.wasm"); std::fs::copy(second, &replacement).unwrap(); let old_hash = smith::sha256::digest_hex(&std::fs::read(&old).unwrap()); let new_hash = smith::sha256::digest_hex(&std::fs::read(&replacement).unwrap()); assert_ne!(old_hash, new_hash); let engine = PluginEngine::new().unwrap(); let packages = PackageRegistry::at(root.join("registry")); for id in ["a", "target"] { let package = root.join(id); std::fs::create_dir(&package).unwrap(); std::fs::copy(&old, package.join("fixture.wasm")).unwrap(); std::fs::write(package.join("plugin.kdl"), format!("id \"fixture:{id}\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"fixture.wasm\"\ncapability \"workspace\"\n")).unwrap(); packages .link(&engine, &package, &[Capability::Workspace]) .unwrap(); } let control_path = root.join("control.sock"); let control = ReloadControl::bind_at_path(control_path.clone()).unwrap(); let grants = CompositionGrants::from_specs(&["fixture:a/fixture=fixture:target/fixture#A".into()]) .unwrap(); let policy = ToolPolicy::from_specs(&["fixture:target/fixture=hidden".into()]).unwrap(); let mut dispatcher = runtime_tools_dispatcher( &root, smith_ai::auth::AuthStore::at(root.join("auth")), false, Some(control), ) .with_package_registry(packages) .with_composition_grants(grants) .with_tool_policy(policy); dispatcher.begin_provider_round().unwrap(); dispatcher.end_provider_round(); let artifact = root.join("target/fixture.wasm"); std::fs::write(&artifact, b"invalid raw path after publication").unwrap(); let (ready, received) = std::sync::mpsc::sync_channel(1); let (release, released) = std::sync::mpsc::sync_channel(1); let reloader = std::thread::spawn(move || { received.recv_timeout(Duration::from_secs(30)).unwrap(); std::fs::copy(replacement, artifact).unwrap(); let mut control = std::os::unix::net::UnixStream::connect(control_path).unwrap(); control .set_read_timeout(Some(Duration::from_secs(5))) .unwrap(); control .set_write_timeout(Some(Duration::from_secs(5))) .unwrap(); control.write_all(b"reload\n").unwrap(); let mut reply = [0; 3]; control.read_exact(&mut reply).unwrap(); assert_eq!(&reply, b"ok\n"); release.send(()).unwrap(); }); let path = root.join("session.smh"); let storage = Arc::new(StorageWorker::start(path.clone())); storage .open(smith::config::Config::default_valid()) .unwrap(); let receipt = storage .admit_foreground("compose", None) .unwrap() .work .receipt; let session = storage.claim(receipt.submission_id).unwrap(); let appended = Arc::clone(&storage); let mut tools = ToolSession::with_persist(&root, session, move |entry, bytes| { appended.append(EntryFrame { id: entry.id, parent: entry.parent, timestamp_ms: entry.timestamp_ms, kind: entry.kind, content: bytes.to_vec(), }) }); let committed = Arc::clone(&storage); let mut signalled = false; tools = tools.with_completion_boundary(receipt.submission_id, move |frame| { let child = frame.entries().iter().any(|entry| { matches!(EntryContent::decode(&entry.content).unwrap(), EntryContent::Meta {kind,detail} if kind == smith_core::metadata::NESTED_INTENT_KIND && serde_json::to_value(&detail).unwrap()["operation"] == "fixture:target/fixture") }); committed.commit_completion(frame)?; if child && !signalled { signalled = true; ready.send(()).unwrap(); released.recv_timeout(Duration::from_secs(10)).unwrap(); } Ok(()) }); tools.set_dispatcher(Box::new(dispatcher)); let rounds = Arc::new(AtomicUsize::new(0)); let requests = Arc::clone(&rounds); let workspace = root.clone(); let stream: smith::provider::StreamFn = Arc::new(move |request, _| { let round = requests.fetch_add(1, Ordering::SeqCst); assert!( request .tools .iter() .any(|tool| tool.name == "fixture:a/fixture") ); assert!( !request .tools .iter() .any(|tool| tool.name == "fixture:target/fixture") ); if round > 0 { assert_eq!( std::fs::read_to_string(workspace.join("A/written.txt")).unwrap(), if round == 1 { "v1 child committed" } else { "v2 child committed" } ); } let events = if round < 2 { vec![ smith::stream::StreamEvent::tool_use( smith::id::MessageId::new(), "fixture:a/fixture", smith::ToolArguments::from_serializable(&serde_json::json!({"mode":"caller"})) .unwrap(), smith::id::ToolCallId::new(), ), smith::stream::StreamEvent::stop(smith::stream::StopReason::ToolUse, None), ] } else { assert_eq!(round, 2); vec![ smith::stream::StreamEvent::text_delta(smith::id::MessageId::new(), "done"), smith::stream::StreamEvent::stop(smith::stream::StopReason::EndTurn, None), ] }; futures::stream::iter(events.into_iter().map(Ok)).boxed() }); let mut agent = Agent::new(stream, tools, "fixture-model"); assert_eq!( agent.run_turn("compose across reload").unwrap().text, "done" ); assert_eq!(rounds.load(Ordering::SeqCst), 3); reloader.join().unwrap(); drop(agent); drop(storage); let mut hashes = Vec::new(); smith_core::store::SessionReader::open(&path) .unwrap() .scan( smith::config::Config::default_valid().frame_bytes_max, |frame| { for entry in frame.entries() { if let EntryContent::Meta { kind, detail } = EntryContent::decode(&entry.content)? && kind == smith_core::metadata::NESTED_INTENT_KIND { let detail = serde_json::to_value(detail).unwrap(); if detail["operation"] == "fixture:target/fixture" { hashes.push( detail["component"]["component_sha256"] .as_str() .unwrap() .to_owned(), ); } } } Ok(()) }, ) .unwrap(); assert_eq!(hashes, [old_hash, new_hash]); composed_agent_stops_after_late_terminal_acknowledgement(&root); std::fs::remove_dir_all(root).unwrap(); } struct LateAcknowledgement { dispatcher: Box, usage: std::sync::Arc, } struct AcknowledgedUsage(std::sync::Arc); impl smith_core::tools::InvocationAllocationObserver for AcknowledgedUsage { fn report(&self) -> smith::Result { let actual_bytes = self.0.load(std::sync::atomic::Ordering::SeqCst) as u64; Ok(smith_core::tools::InvocationAllocationReport { threshold_bytes: 100, actual_bytes, cleanup_bytes: 0, excess_bytes: actual_bytes.saturating_sub(100), allocations: 3, stopped_bytes: None, }) } } impl smith_core::tools::ToolDispatcher for LateAcknowledgement { fn begin_provider_round(&mut self) -> smith::Result { self.dispatcher.begin_provider_round() } fn end_provider_round(&mut self) { self.dispatcher.end_provider_round(); } fn invoke( &mut self, name: &str, input: &smith::ToolArguments, effects: &mut smith_core::tools::ToolEffectContext<'_>, ) -> smith::Result { let result = self.dispatcher.invoke(name, input, effects); // Inject only the observer threshold crossing, after real guest and // primitive execution; persistence acknowledgement advances it. assert!( effects .hold_allocation_observer(Box::new(AcknowledgedUsage(std::sync::Arc::clone( &self.usage )))) .is_none() ); effects.report_allocation(100, 50, 1); result } } fn composed_agent_stops_after_late_terminal_acknowledgement(root: &Path) { use futures::StreamExt; use smith_core::{ agent::Agent, session::{EntryContent, EntryFrame}, tools::ToolSession, }; use smith_harness::{ plugins::registry::PackageRegistry, storage::StorageWorker, wasm::{CompositionGrants, ToolPolicy, runtime_tools_dispatcher}, }; use std::sync::{ Arc, atomic::{AtomicUsize, Ordering}, }; let workspace = root.join("late"); std::fs::create_dir_all(workspace.join("A")).unwrap(); let dispatcher = runtime_tools_dispatcher( &workspace, smith_ai::auth::AuthStore::at(root.join("auth")), false, None, ) .with_package_registry(PackageRegistry::at(root.join("registry"))) .with_composition_grants( CompositionGrants::from_specs(&["fixture:a/fixture=fixture:target/fixture#A".into()]) .unwrap(), ) .with_tool_policy(ToolPolicy::from_specs(&["fixture:target/fixture=hidden".into()]).unwrap()); let path = workspace.join("session.smh"); let storage = Arc::new(StorageWorker::start(path.clone())); storage .open(smith::config::Config::default_valid()) .unwrap(); let receipt = storage .admit_foreground("compose", None) .unwrap() .work .receipt; let session = storage.claim(receipt.submission_id).unwrap(); let appended = Arc::clone(&storage); let mut tools = ToolSession::with_persist(&workspace, session, move |entry, bytes| { appended.append(EntryFrame { id: entry.id, parent: entry.parent, timestamp_ms: entry.timestamp_ms, kind: entry.kind, content: bytes.to_vec(), }) }); let committed = Arc::clone(&storage); let usage = Arc::new(AtomicUsize::new(50)); let acknowledged = Arc::clone(&usage); tools = tools.with_completion_boundary(receipt.submission_id, move |frame| { let terminal = matches!(frame, smith_core::frame::Frame::Commit { .. }); committed.commit_completion(frame)?; if terminal { acknowledged.store(125, Ordering::SeqCst); } Ok(()) }); tools.set_dispatcher(Box::new(LateAcknowledgement { dispatcher: Box::new(dispatcher), usage, })); let requests = Arc::new(AtomicUsize::new(0)); let observed = Arc::clone(&requests); let calls = [smith::id::ToolCallId::new(), smith::id::ToolCallId::new()]; let stream: smith::provider::StreamFn = Arc::new(move |_, _| { assert_eq!( observed.fetch_add(1, Ordering::SeqCst), 0, "no provider request after terminal stop" ); let message = smith::id::MessageId::new(); let mut events = calls .map(|call| { smith::stream::StreamEvent::tool_use( message, "fixture:a/fixture", smith::ToolArguments::from_serializable(&serde_json::json!({"mode":"caller"})) .unwrap(), call, ) }) .to_vec(); events.push(smith::stream::StreamEvent::stop( smith::stream::StopReason::ToolUse, None, )); futures::stream::iter(events.into_iter().map(Ok)).boxed() }); let mut agent = Agent::new(stream, tools, "fixture-model"); let error = agent .run_turn("one completed effect then cleanup stop") .unwrap_err(); assert!(error.to_string().contains("HostAllocation")); assert_eq!(requests.load(Ordering::SeqCst), 1); drop(agent); drop(storage); let mut stops = Vec::new(); let mut completed = Vec::new(); let mut children = 0; let mut following_effect = false; smith_core::store::SessionReader::open(&path) .unwrap() .scan( smith::config::Config::default_valid().frame_bytes_max, |frame| { for entry in frame.entries() { match EntryContent::decode(&entry.content)? { EntryContent::Meta { kind, detail } if kind == smith_core::metadata::INVOCATION_TERMINAL_STOP_KIND => { stops.push( serde_json::from_value::< smith_core::metadata::InvocationTerminalStop, >( serde_json::to_value(detail).unwrap() ) .unwrap(), ) } EntryContent::Meta { kind, detail } if kind == smith_core::metadata::NESTED_INTENT_KIND => { if serde_json::to_value(detail).unwrap()["operation"] == "fixture:target/fixture" { children += 1; } } EntryContent::ToolResult { call_id, ok, .. } => { completed.push((call_id, ok)) } EntryContent::ToolCall { call_id, .. } if call_id == calls[1] => { following_effect = true } _ => {} } } Ok(()) }, ) .unwrap(); assert_eq!(completed, [(calls[0], true)]); assert_eq!(children, 1); assert!(!following_effect); assert_eq!(stops.len(), 1); let stop = &stops[0]; assert_eq!(stop.call_id, calls[0]); assert_eq!(stop.submission_id, Some(receipt.submission_id)); assert_eq!( stop.reason, smith_core::tools::InvocationStop::HostAllocation ); assert_eq!(stop.allocation.actual_bytes, 125); assert_eq!(stop.allocation.cleanup_bytes, 75); assert_eq!(stop.allocation.excess_bytes, 25); assert_eq!( std::fs::read_to_string(workspace.join("A/written.txt")).unwrap(), "v2 child committed" ); }