//! Wasm host lifecycle: validate, instantiate, declare, invoke, fuel //! (`SMH-SPEC-WASM0001`). use smith_core::tools::{ToolEffectContext, ToolSession}; use smith_harness::plugins::{Capability, PluginManifest}; use smith_harness::wasm::bindings::exports::smith::plugin::provider::{ CatalogModel, CatalogSnapshot, CatalogSource, MessageBlock, MessageRole, ModelCapabilities, ProviderMessage, ProviderRequest, ProviderSettings, ProviderTool, SettingsProvenance, ToolUse, }; use smith_harness::wasm::{ PluginEngine, PluginGeneration, PluginInstance, PluginRegistry, coding_tools_dispatcher, }; /// Build a protocol artifact, returning its path. fn protocol_artifact(package: &str, artifact: &str) -> std::path::PathBuf { let status = std::process::Command::new("cargo") .args([ "build", "-p", package, "--target", "wasm32-wasip2", "--locked", ]) .status() .unwrap(); assert!(status.success(), "{package} plugin build failed"); std::path::Path::new(&std::env::var("CARGO_MANIFEST_DIR").unwrap()) .join("../target/wasm32-wasip2/debug") .join(artifact) } fn tool(tools: &mut ToolSession, name: &str, input: &str) -> String { let input = serde_json::from_str(input).unwrap(); tools.invoke(name, &input).unwrap().output } fn instance_tool(instance: &mut PluginInstance, name: &str, input: &str) -> smith::Result { let mut session = ToolSession::new(std::env::temp_dir()); let mut effects = ToolEffectContext::for_operation(&mut session, name); instance.invoke_with_effects(name, input, &mut effects) } fn protocol_manifest(id: &str, artifact: &str) -> PluginManifest { PluginManifest::parse(&format!( "id \"{id}\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"{artifact}\"" )) .unwrap() } /// Build the protocol artifact, returning its path. fn openai_compatible_protocol_artifact() -> std::path::PathBuf { let status = std::process::Command::new("cargo") .args([ "build", "-p", "smith-plugin-protocol-openai-compatible", "--target", "wasm32-wasip2", "--locked", ]) .status() .unwrap(); assert!( status.success(), "OpenAI-compatible protocol plugin build failed" ); let manifest = std::env::var("CARGO_MANIFEST_DIR").unwrap(); std::path::Path::new(&manifest) .join("../target/wasm32-wasip2/debug/smith_plugin_protocol_openai_compatible.wasm") } fn anthropic_protocol_artifact() -> std::path::PathBuf { protocol_artifact( "smith-plugin-protocol-anthropic", "smith_plugin_protocol_anthropic.wasm", ) } fn google_protocol_artifact() -> std::path::PathBuf { protocol_artifact( "smith-plugin-protocol-google", "smith_plugin_protocol_google.wasm", ) } fn echo_artifact() -> std::path::PathBuf { let status = std::process::Command::new("cargo") .args([ "build", "-p", "smith-plugin-echo", "--target", "wasm32-wasip2", ]) .status() .unwrap(); assert!(status.success(), "echo plugin build failed"); let manifest = std::env::var("CARGO_MANIFEST_DIR").unwrap(); std::path::Path::new(&manifest).join("../target/wasm32-wasip2/debug/smith_plugin_echo.wasm") } #[test] fn coding_tools_defer_workspace_validation_until_invocation() { let root = std::env::temp_dir().join(format!("smith-coding-tools-lazy-{}", std::process::id())); let _ = std::fs::remove_dir_all(&root); let mut effects = ToolSession::new(&root); effects.set_dispatcher(Box::new(coding_tools_dispatcher(&root))); effects.begin_provider_round().unwrap(); let input = serde_json::from_str(r#"{"path":"must-not-exist","content":"x"}"#).unwrap(); let error = effects.invoke("write", &input).unwrap_err(); assert!(error.to_string().contains("workspace root is invalid")); } #[test] fn bundled_coding_tools_use_granted_workspace_effects() { let root = std::env::temp_dir().join(format!("smith_coding_tools_{}", std::process::id())); let _ = std::fs::remove_dir_all(&root); std::fs::create_dir_all(&root).unwrap(); std::fs::write(root.join("source.txt"), "alpha\nbeta\n").unwrap(); std::fs::write(root.join(".gitignore"), "ignored.txt\n").unwrap(); std::fs::write(root.join("ignored.txt"), "beta\n").unwrap(); let mut effects = ToolSession::new(root.clone()); effects.set_dispatcher(Box::new(coding_tools_dispatcher(&root))); effects.begin_provider_round().unwrap(); assert_eq!( tool( &mut effects, "read", r#"{"path":"source.txt","offset":1,"limit":1,"max_bytes":6}"# ), "beta\n" ); assert_eq!(tool(&mut effects, "ls", r#"{}"#), "source.txt"); assert_eq!(tool(&mut effects, "find", r#"{"pattern":"ignored"}"#), ""); assert_eq!( tool(&mut effects, "bash", r#"{"command":"printf coding-tools"}"#), "coding-tools" ); tool( &mut effects, "write", r#"{"path":"nested/output.txt","content":"written"}"#, ); tool( &mut effects, "edit", r#"{"path":"nested/output.txt","old_string":"written","new_string":"edited"}"#, ); assert_eq!( std::fs::read_to_string(root.join("nested/output.txt")).unwrap(), "edited" ); assert_eq!( tool(&mut effects, "grep", r#"{"path":"","query":"beta"}"#), "source.txt:2:beta" ); let escaped: smith::structured::ToolArguments = serde_json::from_str(r#"{"path":"../outside","offset":0,"limit":1}"#).unwrap(); assert!( effects .invoke("read", &escaped) .unwrap_err() .to_string() .contains("workspace path escapes") ); #[cfg(unix)] { std::os::unix::fs::symlink(std::env::temp_dir(), root.join("escape")).unwrap(); let escaped: smith::structured::ToolArguments = serde_json::from_str(r#"{"path":"escape/outside","offset":0,"limit":1}"#).unwrap(); assert!( effects .invoke("read", &escaped) .unwrap_err() .to_string() .contains("symbolic link") ); } let _ = std::fs::remove_dir_all(root); } #[cfg(target_os = "linux")] #[test] fn coding_tools_hold_the_workspace_root_across_directory_swap_attempts() { let root = std::env::temp_dir().join(format!("smith-workspace-swap-{}", std::process::id())); let outside = std::env::temp_dir().join(format!("smith-workspace-outside-{}", std::process::id())); let _ = std::fs::remove_dir_all(&root); let _ = std::fs::remove_dir_all(&outside); std::fs::create_dir_all(root.join("swap")).unwrap(); std::fs::create_dir_all(&outside).unwrap(); let mut effects = ToolSession::new(root.clone()); effects.set_dispatcher(Box::new(coding_tools_dispatcher(&root))); effects.begin_provider_round().unwrap(); std::fs::rename(root.join("swap"), root.join("moved")).unwrap(); std::os::unix::fs::symlink(&outside, root.join("swap")).unwrap(); let error = effects .invoke( "write", &serde_json::from_str(r#"{"path":"swap/escape.txt","content":"x"}"#).unwrap(), ) .unwrap_err(); assert!(error.to_string().contains("WRITE_ERROR")); assert!(!outside.join("escape.txt").exists()); assert!(!root.join("moved/escape.txt").exists()); let _ = std::fs::remove_dir_all(&root); let _ = std::fs::remove_dir_all(&outside); } #[test] fn coding_tools_reject_a_session_from_another_workspace_before_effects() { let root_a = std::env::temp_dir().join(format!("smith-workspace-a-{}", std::process::id())); let root_b = std::env::temp_dir().join(format!("smith-workspace-b-{}", std::process::id())); let _ = std::fs::remove_dir_all(&root_a); let _ = std::fs::remove_dir_all(&root_b); std::fs::create_dir_all(&root_a).unwrap(); std::fs::create_dir_all(&root_b).unwrap(); let mut effects = ToolSession::new(&root_b); effects.set_dispatcher(Box::new(coding_tools_dispatcher(&root_a))); effects.begin_provider_round().unwrap(); let input = serde_json::from_str(r#"{"path":"must-not-exist","content":"x"}"#).unwrap(); let error = effects.invoke("write", &input).unwrap_err(); assert!( error .to_string() .contains("workspace authority does not match") ); assert!(!root_a.join("must-not-exist").exists()); assert!(!root_b.join("must-not-exist").exists()); let _ = std::fs::remove_dir_all(root_a); let _ = std::fs::remove_dir_all(root_b); } #[test] fn process_effect_without_grant_fails_before_component_instantiation() { let engine = PluginEngine::new().unwrap(); let manifest = PluginManifest::parse( "id \"smith:coding-tools\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"coding.wasm\"\ncapability \"process\"", ) .unwrap(); let error = match PluginGeneration::load_embedded( &engine, manifest, include_bytes!(concat!(env!("OUT_DIR"), "/smith_plugin_coding_tools.wasm")), &[Capability::Workspace], ) { Err(error) => error, Ok(_) => panic!("filesystem-only grant must reject process capability"), }; assert!(error.to_string().contains("missing grant process")); } #[test] fn workspace_effect_without_grant_fails_before_file_read() { let engine = PluginEngine::new().unwrap(); let manifest = PluginManifest::parse( "id \"smith:coding-tools\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"coding.wasm\"\ncapability \"workspace\"", ) .unwrap(); let error = match PluginGeneration::load_embedded( &engine, manifest, include_bytes!(concat!(env!("OUT_DIR"), "/smith_plugin_coding_tools.wasm")), &[], ) { Err(error) => error, Ok(_) => panic!("missing workspace grant must reject before instantiation"), }; assert!(error.to_string().contains("missing grant workspace")); } #[test] fn echo_plugin_loads_declares_and_invokes() { let artifact = echo_artifact(); let engine = PluginEngine::new().unwrap(); let mut instance = PluginInstance::load(&engine, &artifact).unwrap(); let tools = instance.declare_tools().unwrap(); assert_eq!(tools.len(), 1); assert_eq!(tools[0].name, "echo"); let echoed = instance_tool(&mut instance, "echo", "{\"text\":\"hi\"}").unwrap(); assert_eq!(echoed, "{\"text\":\"hi\"}"); let rejected = match instance_tool(&mut instance, "nope", "{}") { Err(error) => error, Ok(value) => panic!("expected plugin error, got {value}"), }; assert!(rejected.to_string().contains("unknown tool: nope")); } #[test] fn openai_compatible_protocol_keeps_connection_policy_outside_the_guest() { let engine = PluginEngine::new().unwrap(); let manifest = PluginManifest::parse( "id \"smith:protocol-openai-compatible\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"smith_plugin_protocol_openai_compatible.wasm\"", ) .unwrap(); let mut generation = PluginGeneration::load( &engine, manifest, &openai_compatible_protocol_artifact(), &[], ) .unwrap(); assert_eq!(generation.registrations().credential_sources.len(), 1); assert_eq!(generation.registrations().providers.len(), 1); generation .require_protocol_binding( smith_harness::wasm::bindings::exports::smith::plugin::registration::ProtocolBinding::OpenaiCompatible, ) .unwrap(); assert!(generation .require_protocol_binding( smith_harness::wasm::bindings::exports::smith::plugin::registration::ProtocolBinding::GoogleGemini, ) .is_err()); let settings = generation .validate_provider_settings(ProviderSettings { include_usage: true, subscription: false, provenance: SettingsProvenance::BuiltIn, }) .unwrap(); assert!(settings.include_usage); let request = ProviderRequest { code_assist: None, messages: vec![ ProviderMessage { role: MessageRole::User, blocks: vec![MessageBlock::Text("hello".to_string())], }, ProviderMessage { role: MessageRole::Assistant, blocks: vec![ MessageBlock::Thinking("plan".to_string()), MessageBlock::ToolUse(ToolUse { name: "read".to_string(), input_json: r#"{"path":"lib.rs"}"#.to_string(), call_id: "call-1".to_string(), }), ], }, ], tools: vec![ProviderTool { name: "read".to_string(), description: "Read a file".to_string(), input_schema_json: r#"{"type":"object"}"#.to_string(), }], output_tokens_max: None, }; let catalog = CatalogSnapshot { generation: 42, source: CatalogSource::Cache, models: vec![CatalogModel { id: "glm-4".to_string(), capabilities: ModelCapabilities { output_tokens_max: 8192, tool_use: true, thinking: false, }, }], }; let template = generation .build_provider_request("glm-4", &request, settings, &catalog) .unwrap(); assert_eq!(template.url, "https://protocol.invalid/chat/completions"); assert_eq!( template.authorization, "Bearer {{secret:connection-api-key}}" ); assert!(!template.body.contains("connection-api-key")); let body: serde_json::Value = serde_json::from_str(&template.body).unwrap(); assert_eq!(body["tools"][0]["function"]["name"], "read"); assert_eq!( body["messages"][1]["tool_calls"][0]["function"]["arguments"], r#"{"path":"lib.rs"}"# ); let events = generation .decode_provider_chunk( &[], b"data: {\"choices\":[{\"delta\":{\"content\":\"accepted\",\"reasoning_content\":\"thought\"}}]}\n\ndata: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":1,\"completion_tokens\":2}}\n\ndata: [DONE]\n\n", true, ) .unwrap(); assert!(events.events.iter().any(|event| matches!( event, smith_harness::wasm::bindings::exports::smith::plugin::provider::StreamEvent::Thinking(text) if text == "thought" ))); assert!(events.events.iter().any(|event| matches!( event, smith_harness::wasm::bindings::exports::smith::plugin::provider::StreamEvent::Stop((_, Some(usage))) if usage.input_tokens == 1 && usage.output_tokens == 2 ))); } #[test] fn publication_qualifies_connection_sources_and_providers_by_package() { let manifest = |id| { PluginManifest::parse(&format!( "id \"{id}\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"smith_plugin_protocol_openai_compatible.wasm\"\ncapability \"net-scope\"\ncapability \"secret-proxy\"" )) .unwrap() }; let engine = PluginEngine::new().unwrap(); let artifact = openai_compatible_protocol_artifact(); let lower = PluginGeneration::load( &engine, manifest("example:a"), &artifact, &[Capability::NetScope, Capability::SecretProxy], ) .unwrap(); let higher = PluginGeneration::load( &engine, manifest("example:b"), &artifact, &[Capability::NetScope, Capability::SecretProxy], ) .unwrap(); let mut registry = PluginRegistry::new(); registry.publish_all(vec![higher, lower]).unwrap(); let error = match registry.bind_credential_source("test", "connection-api-key") { Ok(_) => panic!("short source alias must be ambiguous"), Err(error) => error, }; assert!( error .to_string() .contains("candidates=[\"example:a\", \"example:b\"]") ); for owner in ["example:a", "example:b"] { let source = format!("{owner}/connection-api-key"); assert_eq!( registry .bind_credential_source("test", &source) .unwrap() .manifest() .id(), owner ); } let duplicate = || { PluginGeneration::load( &engine, manifest("example:a"), &artifact, &[Capability::NetScope, Capability::SecretProxy], ) .unwrap() }; let error = registry .publish_all(vec![duplicate(), duplicate()]) .unwrap_err(); assert!( error .to_string() .contains("duplicate credential source example:a/connection-api-key") ); assert_eq!( registry .bind_credential_source("test", "example:b/connection-api-key") .unwrap() .manifest() .id(), "example:b" ); } #[test] fn protocol_guests_decode_recorded_vendor_conformance_fixtures() { use smith_harness::wasm::bindings::exports::smith::plugin::provider::{ StopReason, StreamEvent, }; let cases = [ ( "smith:protocol-anthropic", "smith_plugin_protocol_anthropic.wasm", anthropic_protocol_artifact(), b"data: {\"type\":\"message_start\",\"message\":{\"usage\":{\"input_tokens\":12}}}\n\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"Look\"}}\n\ndata: {\"type\":\"content_block_delta\",\"index\":1,\"delta\":{\"type\":\"thinking_delta\",\"thinking\":\"hmm\"}}\n\ndata: {\"type\":\"content_block_start\",\"index\":2,\"content_block\":{\"type\":\"tool_use\",\"id\":\"call-anthropic\",\"name\":\"write\"}}\n\ndata: {\"type\":\"content_block_delta\",\"index\":2,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{\\\"path\\\"\"}}\n\ndata: {\"type\":\"content_block_delta\",\"index\":2,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\":\\\"f\\\"}\"}}\n\ndata: {\"type\":\"content_block_stop\",\"index\":2}\n\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\"},\"usage\":{\"output_tokens\":7,\"cache_read_input_tokens\":3}}\n\ndata: {\"type\":\"message_stop\"}\n\n".as_slice(), ), ( "smith:protocol-google", "smith_plugin_protocol_google.wasm", google_protocol_artifact(), b"data: {\"candidates\":[{\"content\":{\"parts\":[{\"text\":\"Writing\"},{\"functionCall\":{\"id\":\"call-google\",\"name\":\"write\",\"args\":{\"path\":\"f\"}}}]},\"finishReason\":\"STOP\"}],\"usageMetadata\":{\"promptTokenCount\":5,\"candidatesTokenCount\":9,\"cachedContentTokenCount\":2}}\n\n".as_slice(), ), ]; let engine = PluginEngine::new().unwrap(); for (id, artifact_name, artifact, bytes) in cases { let mut generation = PluginGeneration::load( &engine, protocol_manifest(id, artifact_name), &artifact, &[], ) .unwrap(); let step = generation .decode_provider_chunk(&[], bytes, true) .unwrap_or_else(|error| panic!("{id}: {error}")); assert!( step.events .iter() .any(|event| matches!(event, StreamEvent::Text(text) if !text.is_empty())), "{id}" ); let expected_call_id = if id.ends_with("google") { "call-google" } else { "call-anthropic" }; assert!(step.events.iter().any(|event| matches!(event, StreamEvent::ToolUse(tool) if tool.name == "write" && tool.input_json == r#"{"path":"f"}"# && tool.call_id == expected_call_id)), "{id}"); if id.ends_with("google") { assert!(step.events.iter().any(|event| matches!(event, StreamEvent::Stop((StopReason::ToolUse, Some(usage))) if usage.input_tokens > 0 && usage.output_tokens > 0))); } else { assert!(step.events.iter().any(|event| matches!(event, StreamEvent::Stop((StopReason::ToolUse, Some(usage))) if usage.input_tokens > 0 && usage.output_tokens > 0))); assert!( step.events .iter() .any(|event| matches!(event, StreamEvent::Thinking(text) if text == "hmm")) ); } } } #[test] fn protocol_guests_preserve_utf8_at_every_chunk_boundary() { let cases = [ ("smith:protocol-anthropic", "smith_plugin_protocol_anthropic.wasm", anthropic_protocol_artifact(), b"data: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"\xe2\x98\x83\"}}\n\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\"}}\n\ndata: {\"type\":\"message_stop\"}\n\n".as_slice()), ("smith:protocol-google", "smith_plugin_protocol_google.wasm", google_protocol_artifact(), b"data: {\"candidates\":[{\"content\":{\"parts\":[{\"text\":\"\xe2\x98\x83\"}]},\"finishReason\":\"STOP\"}]}\n\n".as_slice()), ]; let engine = PluginEngine::new().unwrap(); for (id, artifact_name, artifact, bytes) in cases { let mut generation = PluginGeneration::load( &engine, protocol_manifest(id, artifact_name), &artifact, &[], ) .unwrap(); for split in 0..=bytes.len() { let first = generation .decode_provider_chunk(&[], &bytes[..split], false) .unwrap(); let second = generation .decode_provider_chunk(&first.state, &bytes[split..], true) .unwrap(); assert!(first.events.into_iter().chain(second.events).any(|event| matches!(event, smith_harness::wasm::bindings::exports::smith::plugin::provider::StreamEvent::Text(text) if text == "☃")), "{id} split {split}"); } } } #[test] fn anthropic_guest_preserves_refusal_stop_reason() { let engine = PluginEngine::new().unwrap(); let mut generation = PluginGeneration::load( &engine, protocol_manifest( "smith:protocol-anthropic", "smith_plugin_protocol_anthropic.wasm", ), &anthropic_protocol_artifact(), &[], ) .unwrap(); let response = b"data: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"refusal\"}}\n\ndata: {\"type\":\"message_stop\"}\n\n"; let step = generation .decode_provider_chunk(&[], response, true) .unwrap(); assert!(step.events.iter().any(|event| matches!( event, smith_harness::wasm::bindings::exports::smith::plugin::provider::StreamEvent::Stop(( smith_harness::wasm::bindings::exports::smith::plugin::provider::StopReason::Refusal, _ )) ))); } #[test] fn protocol_guests_reject_malformed_and_provider_error_responses() { let cases = [ ( "smith:protocol-anthropic", "smith_plugin_protocol_anthropic.wasm", anthropic_protocol_artifact(), b"data: {not-json}\n\n".as_slice(), b"data: {\"type\":\"error\",\"error\":{\"message\":\"busy\"}}\n\n".as_slice(), ), ( "smith:protocol-google", "smith_plugin_protocol_google.wasm", google_protocol_artifact(), b"data: {not-json}\n\n".as_slice(), b"data: {\"error\":{\"code\":429,\"message\":\"quota\"}}\n\n".as_slice(), ), ]; let engine = PluginEngine::new().unwrap(); for (id, artifact_name, artifact, malformed, provider_error) in cases { let mut generation = PluginGeneration::load( &engine, protocol_manifest(id, artifact_name), &artifact, &[], ) .unwrap(); assert!( generation .decode_provider_chunk(&[], malformed, true) .is_err(), "{id} malformed" ); assert!( generation .decode_provider_chunk(&[], provider_error, true) .is_err(), "{id} provider error" ); } } #[test] fn openai_compatible_protocol_decodes_utf8_at_every_real_component_byte_split() { let bytes = b"data: {\"choices\":[{\"delta\":{\"content\":\"\xe2\x98\x83\"}}]}\n\ndata: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\ndata: [DONE]\n\n"; let engine = PluginEngine::new().unwrap(); let artifact = openai_compatible_protocol_artifact(); let manifest = PluginManifest::parse( "id \"smith:protocol-openai-compatible\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"smith_plugin_protocol_openai_compatible.wasm\"", ) .unwrap(); let mut generation = PluginGeneration::load(&engine, manifest, &artifact, &[]).unwrap(); for split in 0..=bytes.len() { let first = generation .decode_provider_chunk(&[], &bytes[..split], false) .unwrap(); let second = generation .decode_provider_chunk(&first.state, &bytes[split..], true) .unwrap(); let events = first .events .into_iter() .chain(second.events) .collect::>(); assert!(events.iter().any(|event| matches!( event, smith_harness::wasm::bindings::exports::smith::plugin::provider::StreamEvent::Text(text) if text == "☃" )), "split {split}"); assert!( events.iter().any(|event| matches!( event, smith_harness::wasm::bindings::exports::smith::plugin::provider::StreamEvent::Stop( _ ) )), "split {split}" ); } } #[test] fn openai_compatible_protocol_orders_double_digit_tool_indexes_numerically() { let engine = PluginEngine::new().unwrap(); let manifest = PluginManifest::parse( "id \"smith:protocol-openai-compatible\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"smith_plugin_protocol_openai_compatible.wasm\"", ) .unwrap(); let mut generation = PluginGeneration::load( &engine, manifest, &openai_compatible_protocol_artifact(), &[], ) .unwrap(); let calls = (0..12) .map(|index| { format!( r#"{{"index":{index},"id":"call-{index}","function":{{"name":"tool-{index}","arguments":"{{}}"}}}}"# ) }) .collect::>() .join(","); let response = format!( "data: {{\"choices\":[{{\"delta\":{{\"tool_calls\":[{calls}]}},\"finish_reason\":\"tool_calls\"}}]}}\n\ndata: [DONE]\n\n" ); let step = generation .decode_provider_chunk(&[], response.as_bytes(), true) .unwrap(); let names = step.events.into_iter().filter_map(|event| match event { smith_harness::wasm::bindings::exports::smith::plugin::provider::StreamEvent::ToolUse(tool) => Some(tool.name), _ => None, }).collect::>(); assert_eq!( names, (0..12) .map(|index| format!("tool-{index}")) .collect::>() ); } #[test] fn guest_trap_is_reported() { let artifact = echo_artifact(); let engine = PluginEngine::new().unwrap(); let mut instance = PluginInstance::load(&engine, &artifact).unwrap(); let oversized = "x".repeat(2 * 1024 * 1024); let mut session = ToolSession::new(std::env::temp_dir()); let mut effects = ToolEffectContext::for_operation(&mut session, "echo"); let error = instance .invoke_with_effects("echo", &oversized, &mut effects) .unwrap_err(); assert!(error.to_string().contains("!abort"), "{error}"); assert!(effects.cancel_handle().is_cancelled()); assert!(matches!( instance.invoke_with_effects("echo", "{}", &mut effects), Err(smith::error::SmithError::Cancelled) )); } #[test] fn plugin_refills_its_fuel_budget_for_each_call() { let artifact = echo_artifact(); let engine = PluginEngine::new().unwrap(); let mut instance = PluginInstance::load_with_ceilings( &engine, &artifact, smith_harness::wasm::PluginCeilings { fuel: 100_000, ..Default::default() }, ) .unwrap(); assert_eq!( instance_tool(&mut instance, "echo", "{}"), Ok("{}".to_string()) ); assert_eq!( instance_tool(&mut instance, "echo", "{}"), Ok("{}".to_string()) ); } #[test] fn failed_generation_load_preserves_the_published_generation() { let artifact = echo_artifact(); let engine = PluginEngine::new().unwrap(); let manifest = PluginManifest::parse( "id \"smith:echo\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"smith_plugin_echo.wasm\"", ) .unwrap(); let generation = PluginGeneration::load(&engine, manifest, &artifact, &[]).unwrap(); let mut registry = PluginRegistry::new(); assert!(registry.publish(generation).is_none()); let ungranted = PluginManifest::parse( "id \"smith:echo\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"smith_plugin_echo.wasm\"\ncapability \"log\"", ) .unwrap(); let error = match PluginGeneration::load(&engine, ungranted, &artifact, &[]) { Err(error) => error, Ok(_) => panic!("ungranted capability must reject the generation"), }; assert!(error.to_string().contains("missing grant log")); let mut session = ToolSession::new(std::env::temp_dir()); let mut effects = ToolEffectContext::for_operation(&mut session, "echo"); assert_eq!( registry.invoke_with_effects("echo", "{\"kept\":true}", &mut effects), Ok("{\"kept\":true}".to_string()) ); let mut effects = ToolEffectContext::for_operation(&mut session, "nope"); let error = registry .invoke_with_effects("nope", "{}", &mut effects) .unwrap_err(); assert!(error.to_string().contains("tool nope is not registered")); } #[test] fn generation_load_rejects_unsupported_world_before_execution() { let artifact = echo_artifact(); let engine = PluginEngine::new().unwrap(); let manifest = PluginManifest::parse( "id \"smith:echo\"\nversion \"0.1.0\"\nworld \"9.0.0\"\nartifact \"smith_plugin_echo.wasm\"", ) .unwrap(); let error = match PluginGeneration::load(&engine, manifest, &artifact, &[]) { Err(error) => error, Ok(_) => panic!("unsupported world must reject the generation"), }; assert!( error .to_string() .contains("unsupported world version 9.0.0") ); } #[test] fn generation_load_allows_declared_grants() { let artifact = echo_artifact(); let engine = PluginEngine::new().unwrap(); let manifest = PluginManifest::parse( "id \"smith:echo\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"smith_plugin_echo.wasm\"\ncapability \"log\"", ) .unwrap(); let generation = PluginGeneration::load(&engine, manifest, &artifact, &[Capability::Log]).unwrap(); assert_eq!(generation.tools()[0].name, "echo"); } #[test] fn unmodified_wasip2_std_echo_is_linked_with_fixed_memory() { let artifact = echo_artifact(); let engine = PluginEngine::new().unwrap(); assert!(engine.validate(&artifact).is_ok()); } #[test] fn defined_memory_without_maximum_is_rejected_before_component_validation() { let artifact = fixture( "defined_memory_without_maximum", b"\0asm\x01\0\0\0\x05\x03\x01\0\x01", ); let engine = PluginEngine::new().unwrap(); let error = engine.validate(&artifact).unwrap_err(); assert!(error.to_string().contains("memory maximum is missing")); let _ = std::fs::remove_file(artifact); } #[test] fn imported_memory_without_maximum_is_rejected_before_component_validation() { let artifact = fixture( "imported_memory_without_maximum", b"\0asm\x01\0\0\0\x02\r\x01\x01m\x06memory\x02\0\x01", ); let engine = PluginEngine::new().unwrap(); let error = engine.validate(&artifact).unwrap_err(); assert!(error.to_string().contains("memory maximum is missing")); let _ = std::fs::remove_file(artifact); } #[test] fn defined_table_without_maximum_is_rejected_before_component_validation() { let artifact = fixture( "defined_table_without_maximum", b"\0asm\x01\0\0\0\x04\x04\x01\x70\0\x01", ); let engine = PluginEngine::new().unwrap(); let error = engine.validate(&artifact).unwrap_err(); assert!(error.to_string().contains("table maximum is missing")); let _ = std::fs::remove_file(artifact); } #[test] fn imported_table_without_maximum_is_rejected_before_component_validation() { let artifact = fixture( "imported_table_without_maximum", b"\0asm\x01\0\0\0\x02\r\x01\x01m\x05table\x01\x70\0\x01", ); let engine = PluginEngine::new().unwrap(); let error = engine.validate(&artifact).unwrap_err(); assert!(error.to_string().contains("table maximum is missing")); let _ = std::fs::remove_file(artifact); } #[test] fn mismatched_memory_maximum_is_rejected_before_component_validation() { let artifact = std::env::temp_dir().join(format!( "smith_mismatched_memory_{}.wasm", std::process::id() )); std::fs::write(&artifact, b"\0asm\x01\0\0\0\x05\x04\x01\x01\x01\x02").unwrap(); let engine = PluginEngine::new().unwrap(); let error = engine.validate(&artifact).unwrap_err(); assert!( error .to_string() .contains("memory maximum differs from minimum") ); let _ = std::fs::remove_file(&artifact); } fn fixture(name: &str, bytes: &[u8]) -> std::path::PathBuf { let artifact = std::env::temp_dir().join(format!("smith_{name}_{}.wasm", std::process::id())); std::fs::write(&artifact, bytes).unwrap(); artifact } #[test] fn invalid_artifact_fails_validation() { let junk = std::env::temp_dir().join(format!("smith_junk_{}.wasm", std::process::id())); std::fs::write(&junk, b"not a component").unwrap(); let engine = PluginEngine::new().unwrap(); let Err(error) = PluginInstance::load(&engine, &junk) else { panic!("expected validation failure") }; assert!(error.to_string().contains("validation failed")); let _ = std::fs::remove_file(&junk); } #[test] fn google_guest_accepts_fragmented_eof_event_followed_by_sse_keepalive() { use smith_harness::wasm::bindings::exports::smith::plugin::provider::{ StopReason, StreamEvent, }; let engine = PluginEngine::new().unwrap(); let mut generation = PluginGeneration::load( &engine, protocol_manifest("smith:protocol-google", "smith_plugin_protocol_google.wasm"), &google_protocol_artifact(), &[], ) .unwrap(); for tail in [ "", "\n\n: keepalive", "\n\n: keepalive\n\n", "\n: comment\n", "\n\nevent: message\nid: last\n: keepalive\n\n", ] { let bytes = format!( "data: {{\"candidates\":[{{\"content\":{{\"parts\":[{{\"text\":\"EOF\"}}]}},\"finishReason\":\"STOP\"}}]}}{tail}" ); for split in 0..=bytes.len() { let first = generation .decode_provider_chunk(&[], &bytes.as_bytes()[..split], false) .unwrap(); let second = generation .decode_provider_chunk(&first.state, &bytes.as_bytes()[split..], true) .unwrap(); let events: Vec<_> = first.events.into_iter().chain(second.events).collect(); assert_eq!( events .iter() .filter(|event| matches!(event, StreamEvent::Text(text) if text == "EOF")) .count(), 1, "{tail:?} split {split}" ); assert_eq!( events .iter() .filter(|event| matches!(event, StreamEvent::Stop((StopReason::EndTurn, _)))) .count(), 1, "{tail:?} split {split}" ); } } }