//! Wasm plugin host (`SMH-SPEC-WASM0001`): deterministic engine, artifact validation, //! transactional load, and fuel with memory ceilings. //! //! The engine serves every plugin identically; embedded and user plugins //! load through this one path with no privilege difference. use crate::plugin_control::ReloadControl; use crate::plugins::registry::PackageRegistry; use crate::plugins::{Capability, NetScope, PluginManifest, PluginPackage}; use ::smith::error::{ProviderFault, Result, SmithError}; use serde::Deserialize; use smith::http::HttpExecutor; use smith::structured::{ToolArguments, ToolSchema}; use smith::tool::ToolMetadata; use smith_ai::auth::{AuthStore, CredentialKey, CredentialReference}; use smith_core::tools::{ ToolComponentProvenance, ToolDispatcher, ToolDispatcherSnapshot, ToolEffectContext, ToolLoadoutProvenance, ToolLoadoutTool, WorkspaceRoot, }; use std::cell::Cell; use std::io::Read; use std::path::{Path, PathBuf}; /// Largest accepted component artifact, in bytes. /// Largest accepted component artifact, in bytes. pub const ARTIFACT_BYTES_MAX: usize = 64 * 1024 * 1024; /// Only plugin world supported by this prototype host. pub const SUPPORTED_WORLD_VERSION: &str = "0.1.0"; /// Largest table initial allocation admitted for one plugin. const TABLE_ELEMENTS_MAX: usize = 10_000; /// Largest UTF-8 request, settings, or catalog snapshot crossing into a codec. const CODEC_TEXT_BYTES_MAX: usize = 1024 * 1024; /// Largest model identifier crossing into a codec. const CODEC_MODEL_BYTES_MAX: usize = 256; /// Largest codec state or response chunk crossing into a codec. const CODEC_BINARY_BYTES_MAX: usize = 1024 * 1024; /// Largest provider declaration or decoded event list returned by a codec. const CODEC_ITEMS_MAX: usize = 1_024; const CODING_TOOLS_COMPONENT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/smith_plugin_coding_tools.wasm")); const CODING_TOOLS_METADATA: &str = include_str!(concat!(env!("OUT_DIR"), "/coding_tools_metadata.json")); #[derive(Deserialize)] struct CodingToolMetadata { name: String, description: String, input_schema_json: String, } use wasmtime::component::{Component, Linker}; use wasmtime::{Config, Engine, Store}; mod attachment; mod composition; mod kernel; mod lifecycle; pub use composition::{CompositionGrants, CompositionResourceLimits}; mod sealed_wasi; use attachment::WorkspaceEffects; #[allow(missing_docs, reason = "generated bindings carry no doc comments")] pub mod bindings { // The host world: the guest-facing plugin world plus exactly the WASI // imports Rust std on wasm32-wasip2 pulls in, all served by Smith's // sealed implementations in `sealed_wasi`. wasmtime::component::bindgen!({ path: "../wit", inline: " package smith:host; world plugin-host { include smith:plugin/plugin-world@0.1.0; import wasi:io/error@0.2.12; import wasi:io/poll@0.2.12; import wasi:io/streams@0.2.12; import wasi:clocks/monotonic-clock@0.2.12; import wasi:cli/environment@0.2.12; import wasi:cli/exit@0.2.12; import wasi:cli/stdin@0.2.12; import wasi:cli/stdout@0.2.12; import wasi:cli/stderr@0.2.12; import wasi:cli/terminal-stdin@0.2.12; import wasi:cli/terminal-stdout@0.2.12; import wasi:cli/terminal-stderr@0.2.12; } ", imports: { "wasi:cli/exit.exit": trappable, "wasi:cli/exit.exit-with-code": trappable, }, }); } use self::bindings::PluginHost; use self::bindings::exports::smith::plugin::plugin::ToolDeclaration; use self::bindings::exports::smith::plugin::provider::{ CatalogSnapshot, DecodeStep, ProviderRequest, ProviderSettings, RequestTemplate, }; use self::bindings::exports::smith::plugin::registration::{ProtocolBinding, Registrations}; use self::bindings::smith::plugin::log::Host as LogHost; use self::bindings::smith::plugin::net_scope::Host as NetScopeHost; use self::bindings::smith::plugin::secret_proxy::Host as SecretProxyHost; use self::bindings::smith::plugin::tooling::Host as ToolingHost; /// Deterministic engine configuration per `SMH-SPEC-WASM0001`. pub struct PluginEngine { engine: Engine, } /// Component compiled by this engine and ready for isolated instantiation. pub(crate) struct ValidatedComponent { component: Component, compatibility: ArtifactCompatibility, } #[derive(Clone, Copy, Debug, Default)] struct ArtifactCompatibility { component_private_resources: bool, } impl PluginEngine { /// Build the deterministic engine: NaN canonicalization on, relaxed SIMD /// off, fuel on, and one-frame backtraces. /// /// # Errors /// /// Returns a plugin fault when the engine cannot be configured. pub fn new() -> Result { let mut config = Config::new(); config.cranelift_nan_canonicalization(true); config.wasm_relaxed_simd(false); config.consume_fuel(true); config.epoch_interruption(true); config.wasm_backtrace_max_frames(std::num::NonZeroUsize::new(1)); let engine = Engine::new(&config).map_err(|e| plugin_fault(format!("engine config failed: {e}")))?; Ok(Self { engine }) } /// Validate one artifact against the world; a rejected artifact never /// instantiates. /// /// # Errors /// /// Returns a plugin fault naming the validation stage and cause. pub fn validate(&self, artifact: &Path) -> Result { let metadata = std::fs::metadata(artifact) .map_err(|error| plugin_fault(format!("validation failed: {error}")))?; if metadata.len() > ARTIFACT_BYTES_MAX as u64 { return Err(plugin_fault(format!( "validation failed: artifact exceeds {ARTIFACT_BYTES_MAX} bytes" ))); } let bytes = read_artifact(artifact, metadata.len())?; self.validate_bytes(&bytes) } /// Validate an already embedded component through the same component /// validation path as a package artifact. /// /// # Errors /// /// Returns a plugin fault when the component exceeds a limit or fails /// validation. pub fn validate_bytes(&self, bytes: &[u8]) -> Result { if bytes.len() > ARTIFACT_BYTES_MAX { return Err(plugin_fault(format!( "validation failed: artifact exceeds {ARTIFACT_BYTES_MAX} bytes" ))); } Ok(self.validate_component_bytes(bytes)?.component) } fn validate_component_bytes(&self, bytes: &[u8]) -> Result { if bytes.len() > ARTIFACT_BYTES_MAX { return Err(plugin_fault(format!( "validation failed: artifact exceeds {ARTIFACT_BYTES_MAX} bytes" ))); } let compatibility = validate_declared_limits(bytes)?; let component = Component::from_binary(&self.engine, bytes) .map_err(|error| plugin_fault(format!("validation failed: {error}")))?; Ok(ValidatedComponent { component, compatibility, }) } /// The shared engine behind every plugin. #[must_use] pub const fn engine(&self) -> &Engine { &self.engine } } /// One instantiated plugin: pinned store, fuel budget, and bindings. pub struct PluginInstance { component: Component, store: Store, bindings: PluginHost, raw: wasmtime::component::Instance, } type CredentialConstructor = wasmtime::component::TypedFunc< ( self::bindings::smith::plugin::secret_proxy::ProfileRef, Option, String, ), (wasmtime::component::ResourceAny,), >; type CredentialRenew = wasmtime::component::TypedFunc< (wasmtime::component::ResourceAny,), ( std::result::Result< self::bindings::smith::plugin::secret_proxy::SecretRef, self::bindings::smith::plugin::secret_proxy::AuthorizationFault, >, ), >; /// A fully validated, instantiated, and declared plugin candidate. /// /// Constructing a candidate performs no publication, so a failed load cannot /// change the active registry. pub struct PluginGeneration { manifest: PluginManifest, instance: PluginInstance, tools: Vec, registrations: Registrations, responses_credential_source: Option, lifecycle_handlers: Vec, manifest_sha256: String, component_sha256: String, component_private_resources: bool, } /// Active plugin generation slot. /// /// Replacing this slot is one assignment after every replacement plugin has /// completely loaded, preserving the prior generation on every load failure. #[derive(Default)] pub struct PluginRegistry { generations: Vec, } /// Per-plugin runtime ceilings. #[derive(Clone, Copy, Debug)] pub struct PluginCeilings { /// Memory ceiling in bytes. pub memory_bytes: usize, /// Fuel budget per call. pub fuel: u64, } impl Default for PluginCeilings { fn default() -> Self { Self { memory_bytes: 64 * 1024 * 1024, fuel: 10_000_000_000, } } } struct PluginHostState { /// Host-injected monotonic clock reading; the guest never sees OS time. monotonic_now: u64, ceilings: PluginCeilings, grants: u8, effects_enabled: bool, lifecycle_deadline: Option, lifecycle_allocation_bytes: u64, plugin_id: String, net_scopes: Vec, secret_grants: Vec, oauth_authority: Option>, /// Attached only for one synchronous component invocation. workspace_effects: WorkspaceEffects, /// Once terminal HTTP evidence cannot be persisted, guest success is invalid. fatal_recording_failure: Cell, log_bytes: usize, log_entries: Vec, secret_values: Vec, resolved_secret_refs: Vec, mock_effects: Option, composition: Option>, memory_bytes: usize, table_elements: usize, sealed_handles: u32, } /// One expected mocked host effect in a plugin fixture. #[derive(Clone, Debug, Eq, PartialEq)] pub struct MockEffectPlan { /// WIT operation name. pub operation: String, /// Canonical JSON request supplied by the guest. pub request_json: String, /// Fixed mocked result returned to the guest. pub response: String, } /// Output and ordered host effects observed for one mocked plugin invocation. #[derive(Clone, Debug, Eq, PartialEq)] pub struct MockInvocation { /// Guest return value. pub output: String, /// Ordered effects observed at the host boundary. pub effects: Vec, } /// One host-owned credential authority delegated to a plugin at one origin. /// /// The source identifier never names an arbitrary auth-store entry: it is /// matched only against this explicit grant before resolution at HTTP dispatch. #[derive(Clone)] pub struct SecretGrant { source_id: String, origin: NetScope, scopes: Vec, credential: CredentialReference, auth_store: AuthStore, } /// Persistable, host-owned secret authority for one plugin source. /// /// Plaintext remains in [`AuthStore`] until a matching HTTP header reaches the /// host network boundary. #[derive(Clone, Debug, Eq, PartialEq)] pub struct SecretGrantConfig { source_id: String, origin: NetScope, scopes: Vec, credential_key: CredentialKey, } impl SecretGrantConfig { /// Create one authority from explicit user-selected source, origin, scopes, and credential. /// /// # Errors /// /// Returns a plugin fault for an empty source or an empty scope set. pub fn new( source_id: String, origin: NetScope, scopes: Vec, credential_key: CredentialKey, ) -> Result { if source_id.is_empty() || scopes.is_empty() { return Err(plugin_fault( "secret grant requires a source and at least one scope", )); } let scopes = canonical_secret_scopes(scopes); if scopes.iter().any(|scope| scope != "http-request") { return Err(plugin_fault("secret grant has an unsupported scope")); } Ok(Self { source_id, origin, scopes, credential_key, }) } /// Guest-visible credential source identity. #[must_use] pub fn source_id(&self) -> &str { &self.source_id } /// Explicit HTTP origin receiving this credential. #[must_use] pub const fn origin(&self) -> &NetScope { &self.origin } /// Explicit secret scopes. #[must_use] pub fn scopes(&self) -> &[String] { &self.scopes } /// Auth-store key selected by user configuration. #[must_use] pub const fn credential_key(&self) -> CredentialKey { self.credential_key } /// Attach this declarative authority to one runtime's isolated auth store. #[must_use] pub fn with_auth_store(&self, auth_store: AuthStore) -> SecretGrant { SecretGrant { source_id: self.source_id.clone(), origin: self.origin.clone(), scopes: self.scopes.clone(), credential: CredentialReference::store_or_env(self.credential_key), auth_store, } } } impl SecretGrant { /// Grant one store-or-environment authority to an explicit origin and scopes. #[must_use] pub fn store_or_env( source_id: impl Into, origin: NetScope, scopes: Vec, key: CredentialKey, auth_store: AuthStore, ) -> Self { Self { source_id: source_id.into(), origin, scopes: canonical_secret_scopes(scopes), credential: CredentialReference::store_or_env(key), auth_store, } } } /// One opaque handle bound to one authorized grant and one resolved credential. struct ResolvedSecretRef { grant_index: usize, secret_value_index: u8, } struct MockEffects { plans: Vec, trace: Vec, } const WORKSPACE_GRANT: u8 = 1; const PROCESS_GRANT: u8 = 2; const NET_SCOPE_GRANT: u8 = 4; const SECRET_PROXY_GRANT: u8 = 8; const LOG_GRANT: u8 = 16; const LOG_ENTRIES_MAX: usize = 64; const LOG_BYTES_MAX: usize = 8 * 1024; const RESOLVED_SECRET_REFS_MAX: usize = 32; impl PluginHostState { const fn granted(&self, grant: u8) -> bool { self.grants & grant != 0 } fn limits(&mut self) -> &mut dyn wasmtime::ResourceLimiter { self } } impl wasmtime::ResourceLimiter for PluginHostState { fn memory_growing( &mut self, current: usize, desired: usize, maximum: Option, ) -> wasmtime::Result { let allowed = self.ceilings.memory_growing(current, desired, maximum)?; if allowed { self.memory_bytes += desired; } Ok(allowed) } fn table_growing( &mut self, current: usize, desired: usize, maximum: Option, ) -> wasmtime::Result { let allowed = self.ceilings.table_growing(current, desired, maximum)?; if allowed { self.table_elements += desired; } Ok(allowed) } } impl wasmtime::ResourceLimiter for PluginCeilings { fn memory_growing( &mut self, current: usize, desired: usize, _maximum: Option, ) -> wasmtime::Result { Ok(current == 0 && desired <= self.memory_bytes) } fn table_growing( &mut self, current: usize, desired: usize, _maximum: Option, ) -> wasmtime::Result { Ok(current == 0 && desired <= TABLE_ELEMENTS_MAX) } } impl PluginGeneration { /// Load one trusted package through its manifest-confined artifact. /// /// # Errors /// /// Returns a lifecycle or registration failure without publication. pub fn load_package( engine: &PluginEngine, package: PluginPackage, grants: &[Capability], ) -> Result { let manifest_sha256 = smith::sha256::digest_hex(package.manifest_bytes()); let component_sha256 = smith::sha256::digest_hex(package.artifact_bytes()); let (manifest, artifact) = package.into_parts(); if manifest.id().starts_with("smith:") { return Err(plugin_fault( "external packages cannot claim the reserved smith: identity; choose a non-smith: package id", )); } Self::load_embedded_with_hashes( engine, manifest, &artifact, grants, manifest_sha256, component_sha256, ) } /// Load one manifest-declared plugin after trust resolved its grants. /// /// # Errors /// /// Returns before instantiation when the declared world is unsupported or /// a requested capability lacks a grant; otherwise returns lifecycle or /// declaration failures without publishing anything. pub fn load( engine: &PluginEngine, manifest: PluginManifest, artifact: &Path, grants: &[Capability], ) -> Result { validate_manifest_grants(&manifest, grants)?; let metadata = std::fs::metadata(artifact) .map_err(|error| plugin_fault(format!("validation failed: {error}")))?; if metadata.len() > ARTIFACT_BYTES_MAX as u64 { return Err(plugin_fault(format!( "validation failed: artifact exceeds {ARTIFACT_BYTES_MAX} bytes" ))); } let bytes = read_artifact(artifact, metadata.len())?; Self::load_embedded(engine, manifest, &bytes, grants) } /// Load an embedded component after validating the same manifest and grants /// required for an installed package. /// /// # Errors /// /// Returns before instantiation when the manifest or component is invalid. pub fn load_embedded( engine: &PluginEngine, manifest: PluginManifest, artifact: &[u8], grants: &[Capability], ) -> Result { let manifest_sha256 = manifest_digest(&manifest); let component_sha256 = smith::sha256::digest_hex(artifact); Self::load_embedded_with_hashes( engine, manifest, artifact, grants, manifest_sha256, component_sha256, ) } fn load_embedded_with_hashes( engine: &PluginEngine, manifest: PluginManifest, artifact: &[u8], grants: &[Capability], manifest_sha256: String, component_sha256: String, ) -> Result { validate_manifest_grants(&manifest, grants)?; let component = engine.validate_component_bytes(artifact)?; Self::load_validated_embedded_with_hashes( engine, manifest, &component, grants, manifest_sha256, component_sha256, ) } fn load_validated_embedded_with_hashes( engine: &PluginEngine, manifest: PluginManifest, component: &ValidatedComponent, grants: &[Capability], manifest_sha256: String, component_sha256: String, ) -> Result { validate_manifest_grants(&manifest, grants)?; let mut instance = PluginInstance::instantiate(engine, &component.component, PluginCeilings::default())?; instance.configure_capabilities(manifest.capabilities()); let tools = instance.declare_tools()?; validate_tool_declarations(&tools)?; let registrations = instance.declare_registrations()?; validate_registrations(®istrations)?; let responses_credential_source = instance.declare_responses_binding()?; let lifecycle_handlers = instance.declare_lifecycle()?; instance.configure_plugin_id(manifest.id()); instance.enable_effects(); Ok(Self { manifest, instance, tools, registrations, responses_credential_source, lifecycle_handlers, manifest_sha256, component_sha256, component_private_resources: component.compatibility.component_private_resources, }) } // Versioned kernel-only modules keep their login tools outside inference. // A codec/source component is not kernel-only and retains its contributions. fn credential_module_only(&self) -> bool { self.registrations.providers.is_empty() && self.registrations.models.is_empty() && self.responses_credential_source.is_none() && self .registrations .credential_sources .iter() .any(|source| source.id.ends_with("@1")) } /// Manifest validated for this generation. #[must_use] pub const fn manifest(&self) -> &PluginManifest { &self.manifest } /// SHA-256 of exact manifest bytes loaded for this generation. #[must_use] pub fn manifest_sha256(&self) -> &str { &self.manifest_sha256 } /// SHA-256 of exact component bytes loaded for this generation. #[must_use] pub fn component_sha256(&self) -> &str { &self.component_sha256 } /// Configure explicit network origins resolved at trust or install time. pub fn configure_net_scopes(&mut self, scopes: Vec) { self.instance.configure_net_scopes(scopes); } /// Configure host-owned credential authority for explicit guest exchanges. pub fn configure_secret_grants(&mut self, grants: Vec) { self.instance.configure_secret_grants(grants); } /// Bind explicit host-owned login authority for this generation only. pub fn configure_login_authority(&mut self, authority: crate::oauth::LoginAuthority) { self.instance.store.data_mut().oauth_authority = Some(Box::new(authority)); } fn credential_module_functions(&mut self) -> Result<(CredentialConstructor, CredentialRenew)> { let instance = self.instance.raw; let store = &mut self.instance.store; let interface = instance .get_export_index(&mut *store, None, "smith:plugin/credential-source-v1@0.1.0") .ok_or_else(|| { plugin_fault( "credential consumer openai-chatgpt-plan: missing credential-source-v1 module", ) })?; let constructor = instance .get_export_index( &mut *store, Some(&interface), "[constructor]credential-source", ) .ok_or_else(|| plugin_fault("credential module missing constructor"))?; let renew = instance .get_export_index( &mut *store, Some(&interface), "[method]credential-source.renew", ) .ok_or_else(|| plugin_fault("credential module missing renew"))?; let constructor = instance .get_typed_func::<( self::bindings::smith::plugin::secret_proxy::ProfileRef, Option, String, ), (wasmtime::component::ResourceAny,)>(&mut *store, constructor) .map_err(|_| plugin_fault("credential module constructor has invalid type"))?; let renew = instance .get_typed_func::<(wasmtime::component::ResourceAny,), ( std::result::Result< self::bindings::smith::plugin::secret_proxy::SecretRef, self::bindings::smith::plugin::secret_proxy::AuthorizationFault, >, )>(&mut *store, renew) .map_err(|_| plugin_fault("credential module renew has invalid type"))?; Ok((constructor, renew)) } /// Invoke the optional major-versioned credential module after admitted provider dispatch. /// # Errors /// Rejects missing exports, invalid resource shape, traps, or failed renewal. pub(crate) fn renew_credential_module( &mut self, profile: &str, fixture_issuer: Option<&str>, cancel: smith::tool::CancelHandle, ) -> Result<[String; 3]> { use self::bindings::smith::plugin::secret_proxy::ProfileRef; let (constructor, renew) = self.credential_module_functions()?; let store = &mut self.instance.store; refill_fuel(store)?; let connection_id = store .data() .oauth_authority .as_deref() .ok_or_else(|| plugin_fault("credential module missing selected host authority"))? .connection_id() .to_string(); let (resource,) = constructor .call( &mut *store, ( ProfileRef { id: profile.to_string(), }, fixture_issuer.map(str::to_string), connection_id, ), ) .map_err(|_| plugin_fault("credential module constructor failed"))?; store .data_mut() .oauth_authority .as_deref_mut() .ok_or_else(|| plugin_fault("credential module missing selected host authority"))? .begin_dispatch(cancel); refill_fuel(store)?; let result = renew.call(&mut *store, (resource,)); resource .resource_drop(&mut *store) .map_err(|_| plugin_fault("credential module resource drop failed"))?; let (reference,) = result.map_err(|_| plugin_fault("credential module renewal failed"))?; let reference = reference.map_err(|_| plugin_fault("selected OAuth session unavailable; explicitly reauthorize if renewal is uncertain"))?; if reference.id != profile { return Err(plugin_fault( "credential module returned an unauthorized profile reference", )); } store .data_mut() .oauth_authority .as_deref_mut() .and_then(crate::oauth::LoginAuthority::take_credential) .ok_or_else(|| plugin_fault("credential module returned no host credential")) } // Capture immutable compiled code and validated authority, never a package path. pub(crate) fn protocol_loader(&self) -> impl Fn() -> Result + Send + Sync + use<> { let engine = PluginEngine { engine: self.instance.store.engine().clone(), }; let component = ValidatedComponent { component: self.instance.component.clone(), compatibility: ArtifactCompatibility { component_private_resources: self.component_private_resources, }, }; let manifest = self.manifest.clone(); let manifest_sha256 = self.manifest_sha256.clone(); let component_sha256 = self.component_sha256.clone(); move || { Self::load_validated_embedded_with_hashes( &engine, manifest.clone(), &component, manifest.capabilities(), manifest_sha256.clone(), component_sha256.clone(), ) } } /// Validated tools registered by this generation. #[must_use] pub fn tools(&self) -> &[ToolDeclaration] { &self.tools } pub(crate) fn manifest_id(&self) -> &str { self.manifest.id() } /// Static registrations validated before this generation was published. #[must_use] pub const fn registrations(&self) -> &Registrations { &self.registrations } /// Require the optional major-versioned Responses protocol binding. /// # Errors /// Rejects absent binding or an unexpected credential-source dependency. pub(crate) fn require_responses_binding(&self) -> Result<()> { if self.responses_credential_source.as_deref() != Some("openai-chatgpt-plan@1") { return Err(plugin_fault( "Responses protocol requires openai-chatgpt-plan@1 credential module binding", )); } if !self.manifest.capabilities().contains(&Capability::NetScope) || !self .manifest .capabilities() .contains(&Capability::SecretProxy) { return Err(plugin_fault( "Responses protocol requires net-scope and secret-proxy capabilities", )); } Ok(()) } /// Require one registered provider protocol binding before use. /// /// # Errors /// /// Returns a plugin fault when registration did not declare `binding`. pub fn require_protocol_binding(&self, binding: ProtocolBinding) -> Result<()> { if self .registrations .providers .iter() .any(|provider| same_protocol_binding(provider.protocol, binding)) { Ok(()) } else { Err(plugin_fault( "registration has no matching protocol binding", )) } } fn invoke_with_effects( &mut self, name: &str, input_json: &str, effects: &mut ToolEffectContext<'_>, ) -> Result { if !self.tools.iter().any(|tool| tool.name == name) { return Err(plugin_fault(format!( "invocation failed: tool {name} is not registered" ))); } if self .manifest .capabilities() .contains(&Capability::Workspace) { effects.confine_workspace()?; } effects.set_component_provenance(ToolComponentProvenance { source_id: self.manifest.id().to_string(), manifest_sha256: self.manifest_sha256().to_string(), component_sha256: self.component_sha256().to_string(), }); self.instance.invoke_with_effects(name, input_json, effects) } /// Invoke one declared tool with fixture-owned mocked capability responses. /// /// # Errors /// /// Returns a plugin fault when the tool is undeclared, an effect differs /// from its plan, or the guest output differs from the fixture expectation. pub fn invoke_with_mock_effects( &mut self, name: &str, input_json: &str, plans: Vec, ) -> Result { if !self.tools.iter().any(|tool| tool.name == name) { return Err(plugin_fault(format!( "invocation failed: tool {name} is not registered" ))); } self.instance .invoke_with_mock_effects(name, input_json, plans) } /// Codec-owned settings declared during registration. /// /// # Errors /// /// Returns a plugin fault when declaration traps or exhausts fuel. pub fn provider_settings(&mut self) -> Result { self.instance.declare_provider_settings() } /// Validate and canonicalize one immutable effective configuration snapshot. /// /// # Errors /// /// Returns a plugin fault when validation traps, exhausts fuel, or rejects settings. pub fn validate_provider_settings( &mut self, settings: ProviderSettings, ) -> Result { self.instance.validate_provider_settings(settings) } /// Build one untrusted provider request template through the guest codec. /// /// The returned authorization value is a secret reference, never secret /// plaintext; the host resolves it only at the HTTP effect boundary. /// /// # Errors /// /// Returns a plugin fault when the guest traps, exhausts fuel, or rejects /// the request. pub fn build_provider_request( &mut self, model: &str, request: &ProviderRequest, settings: ProviderSettings, catalog: &CatalogSnapshot, ) -> Result { bound_codec_text("provider model", model, CODEC_MODEL_BYTES_MAX)?; let template = self .instance .build_provider_request(model, request, settings, catalog)?; bound_codec_text("provider template URL", &template.url, CODEC_TEXT_BYTES_MAX)?; bound_codec_text( "provider template authorization", &template.authorization, CODEC_TEXT_BYTES_MAX, )?; bound_codec_text( "provider template body", &template.body, CODEC_TEXT_BYTES_MAX, )?; Ok(template) } /// Decode one bounded response chunk with host-owned codec state. /// /// # Errors /// /// Returns a plugin fault when the guest traps, exhausts fuel, or rejects /// the response. pub fn decode_provider_chunk( &mut self, state: &[u8], chunk: &[u8], finished: bool, ) -> Result { bound_codec_bytes("provider codec state", state, CODEC_BINARY_BYTES_MAX)?; bound_codec_bytes("provider response chunk", chunk, CODEC_BINARY_BYTES_MAX)?; let step = self .instance .decode_provider_chunk(state, chunk, finished)?; bound_codec_bytes( "provider returned codec state", &step.state, CODEC_BINARY_BYTES_MAX, )?; if step.events.len() > CODEC_ITEMS_MAX { return Err(codec_limit( "provider decoded events", step.events.len(), CODEC_ITEMS_MAX, )); } Ok(step) } } /// Dispatches built-in coding tools through the hash-pinned component. pub struct CodingToolsDispatcher { workspace_root: PathBuf, runtime: Option, } struct CodingToolsRuntime { generation: PluginGeneration, workspace_root: PathBuf, workspace: Option, } /// Create a lazy dispatcher for the hash-pinned built-in coding tools. /// /// Component validation, instantiation, and workspace authority acquisition run /// only for an invoked tool, never for a tool-free agent turn. #[must_use] pub fn coding_tools_dispatcher(workspace_root: &Path) -> CodingToolsDispatcher { CodingToolsDispatcher { workspace_root: workspace_root.to_path_buf(), runtime: None, } } fn manifest_digest(manifest: &PluginManifest) -> String { smith::sha256::digest_hex(manifest.id().as_bytes()) } fn load_coding_tools(workspace_root: &Path) -> Result { let metadata = coding_tool_metadata()?; let engine = PluginEngine::new()?; let manifest = PluginManifest::parse( "id \"smith:coding-tools\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"smith_plugin_coding_tools.wasm\"\ncapability \"workspace\"\ncapability \"process\"", )?; // Product-default authority for Smith's hash-pinned built-in component. // `process` is independent from its confined workspace filesystem grant. let mut generation = PluginGeneration::load_embedded( &engine, manifest, CODING_TOOLS_COMPONENT, &[Capability::Workspace, Capability::Process], )?; generation.instance.configure_coding_capabilities(); validate_coding_tool_declarations(generation.tools(), &metadata)?; Ok(CodingToolsRuntime { generation, workspace_root: workspace_root.to_path_buf(), workspace: None, }) } impl CodingToolsDispatcher { fn tools() -> Result> { coding_tool_metadata() } fn owns(&mut self, name: &str) -> Result { Ok(self .runtime()? .generation .tools() .iter() .any(|tool| tool.name == name)) } fn runtime(&mut self) -> Result<&mut CodingToolsRuntime> { if self.runtime.is_none() { self.runtime = Some(load_coding_tools(&self.workspace_root)?); } // The branch above initializes the runtime whenever it was absent. self.runtime .as_mut() .ok_or_else(|| plugin_fault("coding tools runtime initialization failed")) } } impl ToolDispatcher for CodingToolsDispatcher { fn begin_provider_round(&mut self) -> Result { Ok(tool_snapshot( Self::tools()?, ToolComponentProvenance { source_id: "smith:coding-tools".to_string(), manifest_sha256: smith::sha256::digest_hex( b"id \"smith:coding-tools\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"smith_plugin_coding_tools.wasm\"\ncapability \"workspace\"\ncapability \"process\"", ), component_sha256: smith::sha256::digest_hex(CODING_TOOLS_COMPONENT), }, )) } fn invoke( &mut self, name: &str, input: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { let runtime = self.runtime()?; let workspace = if let Some(workspace) = &runtime.workspace { workspace.clone() } else { let workspace = WorkspaceRoot::open(&runtime.workspace_root)?; runtime.workspace = Some(workspace.clone()); workspace }; if !workspace.matches_directory(effects.working_dir())? { return Err(plugin_fault( "workspace authority does not match this tool session", )); } effects.set_workspace_root(workspace); let input_json = serde_json::to_string(input) .map_err(|error| plugin_fault(format!("tool input serialization failed: {error}")))?; runtime .generation .invoke_with_effects(name, &input_json, effects) } } pub(crate) type GenerationLoader = std::sync::Arc Result + Send + Sync>; /// Dispatcher that combines immutable built-in tools with the current user /// package generation. pub use smith_core::tools::ToolPolicyState; /// Explicit per-qualified-tool model-call policy. #[derive(Clone, Debug, Default)] pub struct ToolPolicy { states: Vec<(String, ToolPolicyState)>, } impl ToolPolicy { /// Add one exact qualified tool state. /// /// # Errors /// Returns a plugin fault for an unqualified or duplicate identity. pub fn set(&mut self, name: String, state: ToolPolicyState) -> Result<()> { if !name.contains('/') || self.states.iter().any(|(known, _)| known == &name) { return Err(plugin_fault( "tool policy requires one unique qualified tool identity", )); } self.states.push((name, state)); self.states .sort_unstable_by(|left, right| left.0.cmp(&right.0)); Ok(()) } /// Parse `qualified-name=advertised|hidden|disabled` command-line entries. /// /// # Errors /// Returns a plugin fault naming malformed policy input. pub fn from_specs(specs: &[String]) -> Result { let mut policy = Self::default(); for spec in specs { let (name, state) = spec.split_once('=').ok_or_else(|| { plugin_fault(format!( "tool policy {spec:?} requires qualified-name=advertised|hidden|disabled" )) })?; let state = match state { "advertised" => ToolPolicyState::Advertised, "hidden" => ToolPolicyState::Hidden, "disabled" => ToolPolicyState::Disabled, _ => { return Err(plugin_fault(format!( "tool policy {spec:?} has unknown state; use advertised, hidden, or disabled" ))); } }; policy.set(name.to_string(), state)?; } Ok(policy) } fn state(&self, name: &str) -> ToolPolicyState { self.states .iter() .find(|(known, _)| known == name) .map_or(ToolPolicyState::Advertised, |(_, state)| *state) } } /// Live dispatcher retaining one immutable policy and generation pin per provider round. pub struct RuntimeToolsDispatcher { coding_tools: Option, packages: PackageRegistry, auth_store: AuthStore, engine: Option, plugins: PluginRegistry, control: Option, published: bool, provider: Option, tool_policy: ToolPolicy, tool_authority: ToolPolicy, composition_grants: CompositionGrants, runtime_republish: bool, } /// Create the live package dispatcher for one runtime. /// /// First use and each typed reload notification attempt a complete candidate /// load before publication; a failed candidate leaves the prior generation /// pinned for the active provider request and tool-result batch. /// pub fn runtime_tools_dispatcher( workspace_root: &Path, auth_store: AuthStore, coding_tools_enabled: bool, control: Option, ) -> RuntimeToolsDispatcher { RuntimeToolsDispatcher { coding_tools: coding_tools_enabled.then(|| coding_tools_dispatcher(workspace_root)), packages: PackageRegistry::at_default(), auth_store, engine: None, plugins: PluginRegistry::new(), control, published: false, provider: None, tool_policy: ToolPolicy::default(), tool_authority: ToolPolicy::default(), composition_grants: CompositionGrants::default(), runtime_republish: false, } } impl ToolDispatcher for RuntimeToolsDispatcher { fn has_lifecycle_handlers(&self, boundary: smith::lifecycle::Boundary) -> bool { self.plugins.has_lifecycle_handlers(boundary) } fn begin_provider_round(&mut self) -> Result { let coding_tools = self.coding_tools.as_mut().map_or_else( || Ok(ToolDispatcherSnapshot::default()), ToolDispatcher::begin_provider_round, )?; let reload_requested = self .control .as_ref() .is_some_and(ReloadControl::take_reload_request); if !self.published || reload_requested { self.publish_candidate()?; } if self.runtime_republish { if let (Some(provider), Some(engine)) = (&self.provider, &self.engine) { provider.publish(&mut self.plugins, engine)?; } self.runtime_republish = false; } let mut snapshot = coding_tools; extend_tool_snapshot(&mut snapshot, self.plugins.snapshot_for_role(true)?)?; snapshot.registered_tools = snapshot.tools.clone(); snapshot.policy = snapshot .registered_tools .iter() .map(|tool| (tool.name.clone(), self.tool_policy.state(&tool.name))) .collect(); snapshot .tools .retain(|tool| self.tool_policy.state(&tool.name) == ToolPolicyState::Advertised); snapshot.provenance.tools.retain(|tool| { self.tool_policy.state(&tool.definition.name) == ToolPolicyState::Advertised }); Ok(snapshot) } fn lifecycle( &mut self, event: &smith::lifecycle::LifecycleEvent, cancel: &smith::tool::CancelHandle, ) -> Result { self.plugins .lifecycle(event, cancel, &self.composition_grants) } fn lifecycle_effects( &mut self, event: &smith::lifecycle::LifecycleEvent, effects: &mut ToolEffectContext<'_>, ) -> Result { if !self.plugins.has_lifecycle_handlers(event.boundary) { return Ok(smith::lifecycle::LifecycleBatch::default()); } let deadline = std::time::Instant::now() + std::time::Duration::from_nanos(self.composition_grants.limits().timeout_nanoseconds); let allocation = smith_alloc::AllocationGroup::new() .map_err(|_| plugin_fault("lifecycle allocation observer unavailable"))?; let _allocation = allocation.enter(); let redaction_values = self .provider .as_ref() .map(|owner| owner.redaction_values(&self.auth_store)) .transpose()? .unwrap_or_default(); self.plugins.lifecycle_effects( event, &effects.cancel_handle(), &self.composition_grants, Some(effects), &redaction_values, Some(deadline), ) } fn validate_lifecycle( &self, actions: &[smith::lifecycle::LifecycleAction], model: &str, ) -> Result<()> { use smith::lifecycle::LifecycleAction as A; let changes = || { actions .iter() .flat_map(|action| match action { A::SetToolPolicy(changes) => changes.as_slice(), _ => &[], }) .map(|(name, _)| name.as_str()) }; let additions = changes() .enumerate() .filter(|(index, name)| { !self .tool_policy .states .iter() .any(|(known, _)| known == *name) && !changes().take(*index).any(|prior| prior == *name) }) .count(); if additions > smith::lifecycle::TOOL_POLICY_ITEMS_MAX.saturating_sub(self.tool_policy.states.len()) { return Err(plugin_fault( "lifecycle tool policy exceeds resident item bound", )); } for action in actions { match action { A::SetModel(selected) if selected != model => { self.provider .as_ref() .ok_or_else(|| plugin_fault("model unavailable"))? .validate_model(selected)?; } A::SetProvider(selected) => self .provider .as_ref() .ok_or_else(|| plugin_fault("provider unavailable"))? .validate_provider(selected)?, A::IncludeUsage(_) => { self.provider .as_ref() .ok_or_else(|| plugin_fault("provider settings unavailable"))?; } A::SetToolPolicy(changes) => { for (name, state) in changes { let authority = self.tool_authority.state(name); if authority == ToolPolicyState::Disabled && *state != authority || authority == ToolPolicyState::Hidden && *state == ToolPolicyState::Advertised { return Err(plugin_fault("lifecycle cannot widen host tool authority")); } if !self.plugins.generations.iter().any(|generation| { generation.tools.iter().any(|tool| { qualified_tool_name(generation.manifest.id(), &tool.name) == *name }) }) { return Err(plugin_fault("tool policy target unavailable")); } } } _ => {} } } Ok(()) } fn commit_lifecycle(&mut self, actions: &[smith::lifecycle::LifecycleAction]) { use smith::lifecycle::LifecycleAction as A; for action in actions { match action { A::IncludeUsage(value) => { if let Some(provider) = &mut self.provider { provider.set_include_usage(*value); self.runtime_republish = true; } } A::SetToolPolicy(changes) => { for (name, state) in changes { if let Some((_, prior)) = self .tool_policy .states .iter_mut() .find(|(known, _)| known == name) { *prior = *state; } else { self.tool_policy.states.push((name.clone(), *state)); } } } _ => {} } } } fn invoke( &mut self, name: &str, input: &ToolArguments, effects: &mut ToolEffectContext<'_>, ) -> Result { if self.tool_policy.state(name) == ToolPolicyState::Disabled { return Err(SmithError::Tool { code: smith::error::ToolCode::ToolDisabled, message: format!( "tool '{name}' is disabled by host policy; enable its qualified identity before retrying" ), }); } if let Some(coding_tools) = &mut self.coding_tools && coding_tools.owns(name)? { return coding_tools.invoke(name, input, effects); } let input_json = serde_json::to_string(input) .map_err(|error| plugin_fault(format!("tool input serialization failed: {error}")))?; if !self.composition_grants.has_delegations() { return self .plugins .invoke_for_role(name, &input_json, effects, true); } self.plugins.invoke_composed( name, &input_json, effects, &self.composition_grants, &self.tool_policy, ) } } impl RuntimeToolsDispatcher { fn publish_candidate(&mut self) -> Result<()> { match self.try_publish_candidate() { Ok(()) => { self.published = true; Ok(()) } Err(_retained_error) if self.published => Ok(()), Err(error) => Err(error), } } fn try_publish_candidate(&mut self) -> Result<()> { if self.provider.is_none() && self.packages.list()?.is_empty() { return self.plugins.publish_all(Vec::new()); } if self.engine.is_none() { self.engine = Some(PluginEngine::new()?); } let engine = self .engine .as_ref() .ok_or_else(|| plugin_fault("plugin engine initialization failed"))?; let mut generations = self.packages.load(engine, &self.auth_store)?; if self .provider .as_ref() .is_some_and(crate::protocol::ProviderRoundOwner::subscription) { generations.push(crate::oauth::source::embedded_generation(engine)?); } let mut candidate = PluginRegistry::new(); candidate.publish_all(generations)?; // Parse schemas before publication, not on the first subsequent request. candidate.snapshot_for_role(true)?; if let Some(provider) = &self.provider { provider.publish(&mut candidate, engine)?; } self.plugins = candidate; Ok(()) } /// Apply explicit host-owned model-call policy to qualified plugin tools. #[must_use] pub fn with_tool_policy(mut self, tool_policy: ToolPolicy) -> Self { self.tool_authority = tool_policy.clone(); self.tool_policy = tool_policy; self } /// Set explicit host-owned caller/target filesystem delegations. #[must_use] pub fn with_composition_grants(mut self, grants: CompositionGrants) -> Self { self.composition_grants = grants; self } /// Use an explicitly rooted package registry instead of the XDG default. #[must_use] pub fn with_package_registry(mut self, packages: PackageRegistry) -> Self { self.packages = packages; self } /// Bind ordinary provider dispatch to this dispatcher's round publication. /// /// No request can execute until the first complete candidate publishes. pub fn with_protocol( mut self, connection: crate::protocol::ProtocolConnectionConfig, ) -> (Self, smith::provider::StreamFn) { let (stream, provider) = crate::protocol::provider_round_channel(connection, None); self.provider = Some(provider); (self, stream) } /// Bind qualified registered provider/model/source selection to the same /// candidate as runtime tools. pub fn with_registered_protocol( mut self, connection: crate::protocol::ProtocolConnectionConfig, provider: String, model: String, credential_source: String, ) -> (Self, smith::provider::StreamFn) { let (stream, owner) = crate::protocol::provider_round_channel( connection, Some([provider, model, credential_source]), ); self.provider = Some(owner); (self, stream) } } fn extend_tool_snapshot( snapshot: &mut ToolDispatcherSnapshot, mut other: ToolDispatcherSnapshot, ) -> Result<()> { let component_offset = u16::try_from(snapshot.provenance.components.len()) .map_err(|_| plugin_fault("tool provenance has too many components"))?; for tool in &mut other.provenance.tools { tool.component_index = tool .component_index .checked_add(component_offset) .ok_or_else(|| plugin_fault("tool provenance component index overflow"))?; } snapshot.tools.append(&mut other.tools); snapshot.policy.append(&mut other.policy); snapshot .registered_tools .append(&mut other.registered_tools); snapshot .provenance .components .append(&mut other.provenance.components); snapshot .provenance .tools .append(&mut other.provenance.tools); Ok(()) } fn tool_snapshot( tools: Vec, component: ToolComponentProvenance, ) -> ToolDispatcherSnapshot { let provenance_tools = tools .iter() .cloned() .map(|definition| ToolLoadoutTool { definition, component_index: 0, }) .collect(); ToolDispatcherSnapshot { policy: tools .iter() .map(|tool| (tool.name.clone(), ToolPolicyState::Advertised)) .collect(), registered_tools: tools.clone(), tools, provenance: ToolLoadoutProvenance { components: vec![component], tools: provenance_tools, }, } } impl PluginRegistry { /// Create an empty registry. #[must_use] pub const fn new() -> Self { Self { generations: Vec::new(), } } /// Atomically replace active plugins with one loaded candidate. pub fn publish(&mut self, generation: PluginGeneration) -> Option { let mut prior = std::mem::replace(&mut self.generations, vec![generation]); if prior.len() == 1 { prior.pop() } else { None } } /// Atomically replace the active complete generation. /// /// # Errors /// /// Returns before publication when candidate contributions duplicate an /// identity or request capabilities inconsistent with their bindings. pub fn publish_all(&mut self, mut generations: Vec) -> Result<()> { if generations.len() > 64 || generations .iter() .map(|generation| generation.lifecycle_handlers.len()) .sum::() > 128 { return Err(plugin_fault( "component or lifecycle subscription count exceeds registry bounds", )); } validate_generation_tools(&generations)?; validate_generation_registrations(&generations)?; for generation in &mut generations { if generation .registrations .credential_sources .iter() .any(|source| source.id.ends_with("@1")) { generation.credential_module_functions()?; } } generations.sort_by(|left, right| left.manifest.id().cmp(right.manifest.id())); self.generations = generations; Ok(()) } pub(crate) fn protocol_generation( &self, binding: Option, ) -> Result> { let mut selected = None; for generation in &self.generations { let matches = binding.map_or_else( || generation.require_responses_binding().is_ok(), |binding| generation.require_protocol_binding(binding).is_ok(), ); if matches { if selected.is_some() { return Err(plugin_fault("ambiguous trusted protocol bindings")); } selected = Some(generation); } } Ok(selected) } pub(crate) fn resolve_registered_provider( &self, provider: &str, model: &str, credential_source: &str, ) -> Result<( &PluginGeneration, smith::provider::ProviderRegistrationBinding, )> { let mut candidates = Vec::new(); for generation in &self.generations { for contribution in &generation.registrations.providers { let qualified = qualified_tool_name(generation.manifest.id(), &contribution.id); if provider == qualified || provider == contribution.id { candidates.push((qualified, generation, contribution)); } } } candidates.sort_unstable_by(|left, right| left.0.cmp(&right.0)); if candidates.len() != 1 { let names: Vec<_> = candidates .iter() .map(|candidate| candidate.0.as_str()) .collect(); return Err(plugin_fault(format!( "registered provider {provider} missing or ambiguous; candidates={names:?}" ))); } let (qualified_provider, generation, contribution) = &candidates[0]; generation.require_protocol_binding(contribution.protocol)?; if !generation .manifest .capabilities() .contains(&Capability::NetScope) || !generation .manifest .capabilities() .contains(&Capability::SecretProxy) { return Err(plugin_fault( "registered provider requires net-scope and secret-proxy grants", )); } let qualified_source = qualified_tool_name(generation.manifest.id(), &contribution.credential_source_id); if credential_source != qualified_source { return Err(plugin_fault( "registered provider credential source does not match host binding", )); } let selected_model = generation .registrations .models .iter() .find(|candidate| { candidate.provider_id == contribution.id && (model == candidate.id || model == qualified_tool_name(generation.manifest.id(), &candidate.id)) }) .ok_or_else(|| { plugin_fault("registered model does not belong to selected provider contribution") })?; Ok(( generation, smith::provider::ProviderRegistrationBinding { provider_id: qualified_provider.clone(), model_id: qualified_tool_name(generation.manifest.id(), &selected_model.id), credential_source_id: qualified_source, }, )) } /// Bind one major-versioned credential module to its consumer, never a tool alias. /// # Errors /// Missing or ambiguous candidates name the consumer and sorted candidate manifests. pub fn bind_credential_source( &mut self, consumer: &str, source: &str, ) -> Result<&mut PluginGeneration> { self.bind_credential_source_with_override(consumer, source, None) } /// Bind one credential module selected explicitly by its trusted package identity. /// /// # Errors /// /// Rejects an override that does not implement `source`, and missing or /// ambiguous automatic bindings with sorted candidates and their consumer. pub fn bind_credential_source_with_override( &mut self, consumer: &str, source: &str, implementation: Option<&str>, ) -> Result<&mut PluginGeneration> { let index = credential_binding_index(&self.generations, consumer, source, implementation)?; Ok(&mut self.generations[index]) } /// Remove one selected credential generation while a caller pins it. /// /// The caller must return it through [`Self::return_credential_generation`] /// before another call can select that implementation. pub(crate) fn take_credential_source_with_override( &mut self, consumer: &str, source: &str, implementation: Option<&str>, ) -> Result { let index = credential_binding_index(&self.generations, consumer, source, implementation)?; Ok(self.generations.remove(index)) } /// Return a previously selected credential generation to this published set. pub(crate) fn return_credential_generation(&mut self, generation: PluginGeneration) { self.generations.push(generation); } /// Whether this registry has a published generation. #[must_use] pub const fn is_empty(&self) -> bool { self.generations.is_empty() } /// Snapshot namespaced tool definitions from the complete generation. /// /// # Errors /// /// Returns a plugin fault when a declared schema is invalid JSON. pub fn tools(&self) -> Result> { self.snapshot().map(|snapshot| snapshot.tools) } /// Exact definitions and component identities pinned by this generation. /// /// # Errors /// /// Returns a plugin fault when a declared schema is invalid JSON. pub fn snapshot(&self) -> Result { self.snapshot_for_role(false) } fn snapshot_for_role(&self, inference: bool) -> Result { let mut snapshot = ToolDispatcherSnapshot::default(); for generation in &self.generations { if inference && generation.credential_module_only() { continue; } let tools = generation .tools() .iter() .map(|tool| { ToolSchema::from_json(&tool.input_schema_json) .map(|schema| { ToolMetadata::new( qualified_tool_name(generation.manifest().id(), &tool.name), tool.description.clone(), ) .with_schema(schema) }) .map_err(|error| { plugin_fault(format!( "registration failed: tool {} has invalid input schema: {error}", tool.name )) }) }) .collect::>>()?; extend_tool_snapshot( &mut snapshot, tool_snapshot( tools, ToolComponentProvenance { source_id: generation.manifest().id().to_string(), manifest_sha256: generation.manifest_sha256().to_string(), component_sha256: generation.component_sha256().to_string(), }, ), )?; } Ok(snapshot) } /// Invoke a namespaced tool through the active generation and caller effects. /// /// # Errors /// /// Returns a plugin fault when no active generation owns `name` or the /// guest call fails. pub fn invoke_with_effects( &mut self, name: &str, input_json: &str, effects: &mut ToolEffectContext<'_>, ) -> Result { self.invoke_for_role(name, input_json, effects, false) } fn invoke_for_role( &mut self, name: &str, input_json: &str, effects: &mut ToolEffectContext<'_>, inference: bool, ) -> Result { for generation in &mut self.generations { if inference && generation.credential_module_only() { continue; } let prefix = format!("{}/", generation.manifest().id()); if let Some(tool_name) = name.strip_prefix(&prefix) { return generation.invoke_with_effects(tool_name, input_json, effects); } } let mut matching_generation = None; for (index, generation) in self.generations.iter().enumerate() { if (!inference || !generation.credential_module_only()) && generation.tools().iter().any(|tool| tool.name == name) && matching_generation.replace(index).is_some() { return Err(plugin_fault(format!( "invocation failed: tool alias {name} is ambiguous" ))); } } let Some(index) = matching_generation else { return Err(plugin_fault(format!( "invocation failed: tool {name} is not registered" ))); }; self.generations[index].invoke_with_effects(name, input_json, effects) } } fn coding_tool_metadata() -> Result> { let metadata: Vec = serde_json::from_str(CODING_TOOLS_METADATA) .map_err(|error| plugin_fault(format!("coding tool metadata is invalid: {error}")))?; let declarations: Vec = metadata .iter() .map(|tool| ToolDeclaration { name: tool.name.clone(), description: tool.description.clone(), input_schema_json: tool.input_schema_json.clone(), }) .collect(); validate_tool_declarations(&declarations)?; declarations .into_iter() .map(|tool| { ToolSchema::from_json(&tool.input_schema_json) .map(|schema| ToolMetadata::new(tool.name, tool.description).with_schema(schema)) .map_err(|error| plugin_fault(format!("coding tool metadata is invalid: {error}"))) }) .collect() } fn validate_coding_tool_declarations( declared: &[ToolDeclaration], metadata: &[ToolMetadata], ) -> Result<()> { if declared.len() != metadata.len() || declared.iter().zip(metadata).any(|(declared, metadata)| { declared.name != metadata.name || declared.description != metadata.description }) { return Err(plugin_fault( "coding tool component declarations do not match its hash-pinned metadata", )); } Ok(()) } fn qualified_tool_name(plugin_id: &str, tool_name: &str) -> String { format!("{plugin_id}/{tool_name}") } fn validate_generation_tools(generations: &[PluginGeneration]) -> Result<()> { let mut names = std::collections::BTreeSet::new(); for generation in ordered_generations(generations) { for tool in generation.tools() { let name = qualified_tool_name(generation.manifest().id(), &tool.name); if !names.insert(name.clone()) { return Err(plugin_fault(format!( "registration failed: duplicate tool declaration {name}" ))); } } } Ok(()) } fn validate_generation_registrations(generations: &[PluginGeneration]) -> Result<()> { let mut sources = std::collections::BTreeMap::new(); let mut providers = std::collections::BTreeMap::new(); let mut models = std::collections::BTreeMap::new(); for generation in ordered_generations(generations) { let manifest = generation.manifest(); let registrations = generation.registrations(); if generation.responses_credential_source.is_some() { generation.require_responses_binding()?; } if !registrations.credential_sources.is_empty() && !manifest.capabilities().contains(&Capability::SecretProxy) { return Err(plugin_fault(format!( "registration failed: {} contributes credential sources without secret-proxy capability", manifest.id() ))); } if !registrations.providers.is_empty() && (!manifest.capabilities().contains(&Capability::NetScope) || !manifest.capabilities().contains(&Capability::SecretProxy)) { return Err(plugin_fault(format!( "registration failed: {} contributes providers without net-scope and secret-proxy capabilities", manifest.id() ))); } for source in ®istrations.credential_sources { if !source.id.ends_with("@1") { duplicate_contribution( &mut sources, &source.id, manifest.id(), "credential source", )?; } } for provider in ®istrations.providers { duplicate_contribution(&mut providers, &provider.id, manifest.id(), "provider")?; } for model in ®istrations.models { duplicate_contribution(&mut models, &model.id, manifest.id(), "model")?; } } Ok(()) } fn credential_binding_index( generations: &[PluginGeneration], consumer: &str, source: &str, implementation: Option<&str>, ) -> Result { let mut candidates: Vec<_> = generations .iter() .enumerate() .filter(|(_, generation)| { generation .registrations() .credential_sources .iter() .any(|candidate| { candidate.id == source || qualified_tool_name(generation.manifest().id(), &candidate.id) == source }) }) .map(|(index, generation)| (generation.manifest().id(), index)) .collect(); candidates.sort_unstable(); if let Some(implementation) = implementation { if let Some((_, index)) = candidates .iter() .find(|(candidate, _)| *candidate == implementation) { return Ok(*index); } let names: Vec<_> = candidates.iter().map(|(name, _)| *name).collect(); return Err(plugin_fault(format!( "credential consumer {consumer} override {implementation} requires {source}; candidates={names:?}" ))); } if candidates.len() != 1 { let names: Vec<_> = candidates.iter().map(|(name, _)| *name).collect(); return Err(plugin_fault(format!( "credential consumer {consumer} requires {source}; candidates={names:?}" ))); } Ok(candidates[0].1) } fn ordered_generations(generations: &[PluginGeneration]) -> Vec<&PluginGeneration> { let mut ordered: Vec<_> = generations.iter().collect(); ordered.sort_by(|left, right| left.manifest().id().cmp(right.manifest().id())); ordered } fn duplicate_contribution( owners: &mut std::collections::BTreeMap, id: &str, owner: &str, kind: &str, ) -> Result<()> { let qualified = qualified_tool_name(owner, id); if let Some(prior) = owners.insert(qualified.clone(), owner.to_string()) { return Err(plugin_fault(format!( "registration failed: duplicate {kind} {qualified} from {prior} and {owner}" ))); } Ok(()) } impl PluginInstance { /// Validate, instantiate, and pin one plugin with default ceilings. /// /// # Errors /// /// Returns a plugin fault naming the failed lifecycle stage. pub fn load(engine: &PluginEngine, artifact: &Path) -> Result { Self::load_with_ceilings(engine, artifact, PluginCeilings::default()) } /// Validate, instantiate, and pin one plugin with explicit ceilings. /// /// Every guest entry point receives `ceilings.fuel`; no call inherits a /// prior call's remaining budget. /// /// # Errors /// /// Returns a plugin fault naming the failed lifecycle stage. pub fn load_with_ceilings( engine: &PluginEngine, artifact: &Path, ceilings: PluginCeilings, ) -> Result { let component = engine.validate(artifact)?; Self::instantiate(engine, &component, ceilings) } /// Validate and instantiate one component embedded in the release. /// /// # Errors /// /// Returns a lifecycle failure without bypassing component validation. pub fn load_bytes(engine: &PluginEngine, artifact: &[u8]) -> Result { let component = engine.validate_bytes(artifact)?; Self::instantiate(engine, &component, PluginCeilings::default()) } fn configure_capabilities(&mut self, capabilities: &[Capability]) { self.store.data_mut().grants = capabilities.iter().fold(0, |grants, capability| { grants | match capability { Capability::Workspace => WORKSPACE_GRANT, Capability::Process => PROCESS_GRANT, Capability::NetScope => NET_SCOPE_GRANT, Capability::SecretProxy => SECRET_PROXY_GRANT, Capability::Log => LOG_GRANT, } }); } fn configure_coding_capabilities(&mut self) { self.configure_capabilities(&[Capability::Workspace, Capability::Process]); } fn configure_plugin_id(&mut self, plugin_id: &str) { self.store.data_mut().plugin_id = plugin_id.to_string(); } fn enable_effects(&mut self) { self.store.data_mut().effects_enabled = true; } fn configure_net_scopes(&mut self, scopes: Vec) { self.store.data_mut().net_scopes = scopes; } fn configure_secret_grants(&mut self, grants: Vec) { let state = self.store.data_mut(); state.secret_grants = grants; state.secret_values.clear(); state.resolved_secret_refs.clear(); } fn instantiate( engine: &PluginEngine, component: &Component, ceilings: PluginCeilings, ) -> Result { let mut store = Store::new( engine.engine(), PluginHostState { composition: None, memory_bytes: 0, table_elements: 0, sealed_handles: 0, monotonic_now: 0, ceilings, grants: 0, effects_enabled: false, lifecycle_deadline: None, lifecycle_allocation_bytes: 0, plugin_id: String::new(), net_scopes: Vec::new(), secret_grants: Vec::new(), oauth_authority: None, workspace_effects: WorkspaceEffects::default(), fatal_recording_failure: Cell::new(false), log_bytes: 0, log_entries: Vec::new(), secret_values: Vec::new(), resolved_secret_refs: Vec::new(), mock_effects: None, }, ); store.limiter(PluginHostState::limits); store.set_epoch_deadline(u64::MAX / 2); refill_fuel(&mut store)?; let mut linker: Linker = Linker::new(engine.engine()); PluginHost::add_to_linker::(&mut linker, |state| state) .map_err(|e| plugin_fault(format!("linker setup failed: {e}")))?; sealed_wasi::link(&mut linker).map_err(|error| plugin_fault(error.to_string()))?; composition::link(&mut linker) .map_err(|error| plugin_fault(format!("composition linker: {error}")))?; let raw = linker .instantiate(&mut store, component) .map_err(|e| plugin_fault(format!("instantiation failed: {e}")))?; let bindings = PluginHost::new(&mut store, &raw) .map_err(|e| plugin_fault(format!("binding failed: {e}")))?; Ok(Self { component: component.clone(), store, bindings, raw, }) } fn declare_responses_binding(&mut self) -> Result> { let Some(interface) = self.raw.get_export_index( &mut self.store, None, "smith:plugin/protocol-openai-responses-v1@0.1.0", ) else { return Ok(None); }; let export = self .raw .get_export_index(&mut self.store, Some(&interface), "credential-source") .ok_or_else(|| { plugin_fault("Responses protocol binding missing credential-source declaration") })?; let declaration = self .raw .get_typed_func::<(), (String,)>(&mut self.store, export) .map_err(|_| plugin_fault("Responses protocol binding has invalid declaration type"))?; refill_fuel(&mut self.store)?; let (source,) = declaration .call(&mut self.store, ()) .map_err(|_| plugin_fault("Responses protocol binding declaration failed"))?; if source.is_empty() || source.len() > 256 { return Err(plugin_fault( "Responses credential-source binding exceeds identity bounds", )); } Ok(Some(source)) } /// The declared tool set; runs the declaration pass. /// /// # Errors /// /// Returns a plugin fault on trap, fuel exhaustion, or conversion /// failure. pub fn declare_tools(&mut self) -> Result> { refill_fuel(&mut self.store)?; let interface = self .bindings .smith_plugin_plugin() .call_declare_tools(&mut self.store) .map_err(|e| plugin_fault(format!("declaration failed: {e}")))?; Ok(interface) } fn declare_registrations(&mut self) -> Result { refill_fuel(&mut self.store)?; self.bindings .smith_plugin_registration() .call_declare(&mut self.store) .map_err(|error| plugin_fault(format!("registration declaration failed: {error}"))) } /// Invoke one declared tool by name. /// /// # Errors /// /// Returns a plugin fault on trap, fuel exhaustion, or a guest error; /// guest errors carry the plugin's own message. pub fn invoke_with_effects( &mut self, name: &str, input_json: &str, effects: &mut ToolEffectContext<'_>, ) -> Result { if effects.cancel_handle().is_cancelled() { return Err(SmithError::Cancelled); } refill_fuel(&mut self.store)?; if self.store.data().fatal_recording_failure.get() { return Err(plugin_fault( "plugin session has a fatal HTTP recording failure", )); } self.reset_log_budget(); let _scope = attach_workspace_effects(&self.store, effects)?; let outcome = self .bindings .smith_plugin_plugin() .call_invoke(&mut self.store, name, input_json) .map_err(|error| { let reason = if matches!( error.downcast_ref::(), Some(wasmtime::Trap::OutOfFuel) ) { smith_core::tools::InvocationStop::Fuel } else { smith_core::tools::InvocationStop::Sandbox }; effects.stop(reason); plugin_fault(format!("invoke failed: {error}")) }); if self.store.data().fatal_recording_failure.get() { return Err(plugin_fault( "plugin invocation has a fatal HTTP recording failure", )); } outcome? .map(|text| redact_secret_message(&text, &self.store.data().secret_values)) .map_err(|message| { plugin_fault(format!( "plugin error: {}", redact_secret_message(&message, &self.store.data().secret_values) )) }) } /// Invoke one declared tool with fixture-owned mocked capability responses. /// /// # Errors /// /// Returns a plugin fault when the invocation fails, an effect differs from /// the fixture plan, or the guest leaves planned effects unused. pub fn invoke_with_mock_effects( &mut self, name: &str, input_json: &str, plans: Vec, ) -> Result { refill_fuel(&mut self.store)?; if self.store.data().mock_effects.is_some() { return Err(plugin_fault("mock effect context is already attached")); } self.reset_log_budget(); self.store.data_mut().mock_effects = Some(MockEffects { plans, trace: Vec::new(), }); let outcome = self .bindings .smith_plugin_plugin() .call_invoke(&mut self.store, name, input_json) .map_err(|error| plugin_fault(format!("invoke failed: {error}"))); let mock = self .store .data_mut() .mock_effects .take() .ok_or_else(|| plugin_fault("mock effect context was lost"))?; let output = outcome?.map_err(|message| plugin_fault(format!("plugin error: {message}")))?; if mock.trace.len() != mock.plans.len() { return Err(plugin_fault(format!( "fixture effect plan has {} unconsumed effect(s)", mock.plans.len() - mock.trace.len() ))); } Ok(MockInvocation { output, effects: mock.trace, }) } fn reset_log_budget(&mut self) { let state = self.store.data_mut(); state.log_bytes = 0; state.log_entries.clear(); state.secret_values.clear(); state.resolved_secret_refs.clear(); } fn declare_provider_settings(&mut self) -> Result { refill_fuel(&mut self.store)?; self.bindings .smith_plugin_provider() .call_declare_settings(&mut self.store) .map_err(|error| plugin_fault(format!("provider settings declaration failed: {error}"))) } fn validate_provider_settings( &mut self, settings: ProviderSettings, ) -> Result { refill_fuel(&mut self.store)?; let outcome = self .bindings .smith_plugin_provider() .call_validate_settings(&mut self.store, settings) .map_err(|error| { plugin_fault(format!("provider settings validation failed: {error}")) })?; outcome.map_err(|message| plugin_fault(format!("plugin error: {message}"))) } fn build_provider_request( &mut self, model: &str, request: &ProviderRequest, settings: ProviderSettings, catalog: &CatalogSnapshot, ) -> Result { refill_fuel(&mut self.store)?; let outcome = self .bindings .smith_plugin_provider() .call_build_request(&mut self.store, model, request, settings, catalog) .map_err(|error| plugin_fault(format!("provider request failed: {error}")))?; outcome.map_err(|message| plugin_fault(format!("plugin error: {message}"))) } fn decode_provider_chunk( &mut self, state: &[u8], chunk: &[u8], finished: bool, ) -> Result { refill_fuel(&mut self.store)?; let outcome = self .bindings .smith_plugin_provider() .call_decode_response(&mut self.store, state, chunk, finished) .map_err(|error| plugin_fault(format!("provider decode failed: {error}")))?; outcome.map_err(|message| plugin_fault(format!("plugin error: {message}"))) } } fn validate_manifest_grants(manifest: &PluginManifest, grants: &[Capability]) -> Result<()> { if manifest.world_version() != SUPPORTED_WORLD_VERSION { return Err(plugin_fault(format!( "unsupported world version {}; supported version is {SUPPORTED_WORLD_VERSION}; rebuild the plugin against the supported world", manifest.world_version() ))); } for capability in manifest.capabilities() { if !grants.contains(capability) { return Err(plugin_fault(format!( "instantiation failed: missing grant {}", capability.name() ))); } } Ok(()) } const fn same_protocol_binding(left: ProtocolBinding, right: ProtocolBinding) -> bool { matches!( (left, right), ( ProtocolBinding::OpenaiCompatible, ProtocolBinding::OpenaiCompatible ) | ( ProtocolBinding::AnthropicMessages, ProtocolBinding::AnthropicMessages ) | (ProtocolBinding::GoogleGemini, ProtocolBinding::GoogleGemini) ) } fn validate_registrations(registrations: &Registrations) -> Result<()> { for (index, source) in registrations.credential_sources.iter().enumerate() { if source.id.is_empty() || registrations.credential_sources[..index] .iter() .any(|prior| prior.id == source.id) { return Err(plugin_fault( "registration has an empty or duplicate credential source", )); } } for (index, provider) in registrations.providers.iter().enumerate() { if provider.id.is_empty() || provider.credential_source_id.is_empty() || !registrations .credential_sources .iter() .any(|source| source.id == provider.credential_source_id) || registrations.providers[..index] .iter() .any(|prior| prior.id == provider.id) { return Err(plugin_fault( "registration has an invalid provider contribution", )); } } for (index, model) in registrations.models.iter().enumerate() { if model.id.is_empty() || !registrations .providers .iter() .any(|provider| provider.id == model.provider_id) || registrations.models[..index] .iter() .any(|prior| prior.id == model.id) { return Err(plugin_fault( "registration has an invalid model contribution", )); } } Ok(()) } fn validate_tool_declarations(tools: &[ToolDeclaration]) -> Result<()> { for (index, tool) in tools.iter().enumerate() { if tool.name.is_empty() || tool.description.is_empty() { return Err(plugin_fault( "registration failed: tool name and description must not be empty", )); } ToolSchema::from_json(&tool.input_schema_json).map_err(|error| { plugin_fault(format!( "registration failed: tool {} has invalid input schema: {error}", tool.name )) })?; if tools[..index].iter().any(|prior| prior.name == tool.name) { return Err(plugin_fault(format!( "registration failed: duplicate tool declaration {}", tool.name ))); } } Ok(()) } fn read_artifact(artifact: &Path, expected_bytes: u64) -> Result> { let capacity = usize::try_from(expected_bytes) .map_err(|_| plugin_fault("validation failed: artifact exceeds addressable memory"))?; let mut bytes = Vec::new(); bytes .try_reserve_exact(capacity) .map_err(|_| plugin_fault("validation failed: artifact allocation failed"))?; let file = std::fs::File::open(artifact) .map_err(|error| plugin_fault(format!("validation failed: {error}")))?; #[expect( clippy::disallowed_methods, reason = "Take caps this read at ARTIFACT_BYTES_MAX + 1 before overflow is reported" )] file.take((ARTIFACT_BYTES_MAX + 1) as u64) .read_to_end(&mut bytes) .map_err(|error| plugin_fault(format!("validation failed: {error}")))?; if bytes.len() > ARTIFACT_BYTES_MAX { return Err(plugin_fault(format!( "validation failed: artifact exceeds {ARTIFACT_BYTES_MAX} bytes" ))); } Ok(bytes) } fn validate_declared_limits(bytes: &[u8]) -> Result { let mut compatibility = ArtifactCompatibility::default(); for payload in wasmparser::Parser::new(0).parse_all(bytes) { match payload.map_err(|error| plugin_fault(format!("validation failed: {error}")))? { wasmparser::Payload::ImportSection(imports) => { for import in imports.into_imports() { match import .map_err(|error| plugin_fault(format!("validation failed: {error}")))? .ty { wasmparser::TypeRef::Memory(memory) => validate_memory(&memory)?, wasmparser::TypeRef::Table(table) => validate_table(&table)?, _ => {} } } } wasmparser::Payload::MemorySection(memories) => { for memory in memories { let memory = memory .map_err(|error| plugin_fault(format!("validation failed: {error}")))?; validate_memory(&memory)?; } } wasmparser::Payload::TableSection(tables) => { for table in tables { let table = table .map_err(|error| plugin_fault(format!("validation failed: {error}")))?; validate_table(&table.ty)?; } } wasmparser::Payload::ComponentCanonicalSection(functions) => { for function in functions { if matches!( function .map_err(|error| plugin_fault(format!("validation failed: {error}")))?, wasmparser::CanonicalFunction::ResourceNew { .. } ) { compatibility.component_private_resources = true; } } } wasmparser::Payload::ComponentExportSection(exports) => { for export in exports { let export = export .map_err(|error| plugin_fault(format!("validation failed: {error}")))?; validate_component_export(export.name.name)?; } } _ => {} } } Ok(compatibility) } fn validate_component_export(name: &str) -> Result<()> { if name.starts_with("smith:") && !name.starts_with("smith:plugin/") { return Err(plugin_fault(format!( "validation failed: external artifact exports reserved Smith contract {name}; use a non-smith: contract" ))); } Ok(()) } fn validate_memory(memory: &wasmparser::MemoryType) -> Result<()> { let Some(maximum) = memory.maximum else { return Err(plugin_fault("validation failed: memory maximum is missing")); }; if maximum != memory.initial { return Err(plugin_fault( "validation failed: memory maximum differs from minimum", )); } Ok(()) } fn validate_table(table: &wasmparser::TableType) -> Result<()> { let Some(maximum) = table.maximum else { return Err(plugin_fault("validation failed: table maximum is missing")); }; if maximum != table.initial { return Err(plugin_fault( "validation failed: table maximum differs from minimum", )); } Ok(()) } fn refill_fuel(store: &mut Store) -> Result<()> { let fuel = store.data().ceilings.fuel; store .set_fuel(fuel) .map_err(|error| plugin_fault(format!("fuel setup failed: {error}"))) } fn bound_codec_text(name: &str, text: &str, limit: usize) -> Result<()> { bound_codec_bytes(name, text.as_bytes(), limit) } fn bound_codec_bytes(name: &str, bytes: &[u8], limit: usize) -> Result<()> { if bytes.len() > limit { return Err(codec_limit(name, bytes.len(), limit)); } Ok(()) } fn codec_limit(name: &str, actual: usize, limit: usize) -> SmithError { plugin_fault(format!("{name} exceeds {limit} bytes or items: {actual}")) } fn plugin_fault(message: impl Into) -> SmithError { SmithError::Provider { fault: ProviderFault::Plugin { message: message.into(), }, } } /// Self-referential data marker for linker setup. struct PluginHasSelf; impl wasmtime::component::HasData for PluginHasSelf { type Data<'a> = &'a mut PluginHostState; } fn effects_enabled(state: &PluginHostState) -> std::result::Result<(), String> { if state.effects_enabled { Ok(()) } else { Err("host effects are unavailable during plugin registration".to_string()) } } impl bindings::smith::plugin::composition::Host for PluginHostState { fn invoke(&mut self, _: String, _: String) -> std::result::Result { Err("composition is not attached".into()) } } impl LogHost for PluginHostState { fn write(&mut self, level: String, message: String) -> std::result::Result<(), String> { effects_enabled(self)?; if self.lifecycle_deadline.is_some() { return Err("lifecycle log effects unavailable".into()); } if !self.granted(LOG_GRANT) { return Err("log capability is not granted".to_string()); } if level.is_empty() || message.is_empty() { return Err("log level and message must not be empty".to_string()); } let bytes = level .len() .checked_add(message.len()) .ok_or_else(|| "log message byte count overflowed".to_string())?; if self.log_entries.len() >= LOG_ENTRIES_MAX || self .log_bytes .checked_add(bytes) .is_none_or(|total| total > LOG_BYTES_MAX) { return Err("log invocation exceeds its explicit host bounds".to_string()); } let level = redact_secret_message(&level, &self.secret_values); let message = redact_secret_message(&redact_log_message(&message), &self.secret_values); if self.mock_effects.is_some() { mock_effect( self, "log-write", &serde_json::json!({"level": level, "message": message}), )?; } else { let plugin_id = self.plugin_id.clone(); workspace_effect_context(self)? .record_plugin_log(&smith::http::PluginLogRecord { plugin_id, level: level.clone(), message: message.clone(), }) .map_err(|error| error.to_string())?; } self.log_bytes += bytes; self.log_entries.push(format!("{level}:{message}")); Ok(()) } } fn redact_log_message(message: &str) -> String { let mut redact_next = false; message .split_whitespace() .map(|part| { if std::mem::take(&mut redact_next) { return ""; } let lower = part.to_ascii_lowercase(); let header = lower.starts_with("authorization:") || lower.starts_with("x-api-key:") || lower.starts_with("x-goog-api-key:"); if header { redact_next = part.ends_with(':'); "" } else { part } }) .collect::>() .join(" ") } fn redact_secret_message(message: &str, secrets: &[String]) -> String { secrets .iter() .fold(message.to_string(), |redacted, secret| { if secret.is_empty() { return redacted; } // Nested evidence contains JSON strings, including object keys. // Replace escaped spelling too, not only raw credential bytes. let Ok(quoted) = serde_json::to_string(secret) else { return "".into(); }; redacted .replace("ed[1..quoted.len() - 1], "") .replace(secret, "") }) } impl NetScopeHost for PluginHostState { fn request( &mut self, request: self::bindings::smith::plugin::net_scope::HttpRequest, ) -> std::result::Result { effects_enabled(self)?; if !self.granted(NET_SCOPE_GRANT) { return Err("net-scope capability is not granted".to_string()); } if self.mock_effects.is_some() { let response = mock_effect( self, "http-request", &serde_json::json!({ "destination": request.destination, "method": request.method, "headers": request.headers.into_iter().map(|header| serde_json::json!({"name": header.name, "value": header.value})).collect::>(), "body": request.body, "options": {"timeout_ms": request.options.timeout_ms, "response_bytes_max": request.options.response_bytes_max}, }), )?; return mock_http_response(&response); } net_scope_request(self, request) } } const fn authorization_fault( fault: &crate::oauth::AuthorizationFault, ) -> self::bindings::smith::plugin::secret_proxy::AuthorizationFault { use self::bindings::smith::plugin::secret_proxy::AuthorizationFault; use crate::oauth::AuthorizationFault as HostFault; match fault { HostFault::Cancelled => AuthorizationFault::Cancelled, HostFault::Deadline => AuthorizationFault::DeadlineExceeded, HostFault::ExchangeUncertain => AuthorizationFault::ExchangeUncertain, HostFault::Network => AuthorizationFault::Network, HostFault::Storage(_) => AuthorizationFault::Storage, HostFault::Authority => AuthorizationFault::Authority, HostFault::Rejected(_) | HostFault::ReauthenticationRequired => { AuthorizationFault::Rejected } } } fn oauth_policy( policy: self::bindings::smith::plugin::secret_proxy::LoginPolicy, ) -> crate::oauth::LoginPolicy { crate::oauth::LoginPolicy { flow: match policy.flow { self::bindings::smith::plugin::secret_proxy::LoginFlow::DynamicOidc => { crate::oauth::LoginFlow::DynamicOidc } self::bindings::smith::plugin::secret_proxy::LoginFlow::GoogleInstalledPkce => { crate::oauth::LoginFlow::GoogleInstalledPkce } self::bindings::smith::plugin::secret_proxy::LoginFlow::FixedClientPkceOpaque => { crate::oauth::LoginFlow::FixedClientPkceOpaque } }, connection_id: policy.connection_id, token_origin: policy.token_origin, issuer: policy.issuer, resource: policy.audience, initial_client: policy.initial_client, issued_prefix: policy.issued_prefix, authorization_path: policy.authorization_path, token_path: policy.token_path, agent_name: policy.agent_name, scopes: policy.scopes, required_scopes: policy.required_scopes, } } impl SecretProxyHost for PluginHostState { fn end_session( &mut self, profile: self::bindings::smith::plugin::secret_proxy::ProfileRef, ) -> std::result::Result { use self::bindings::smith::plugin::secret_proxy::AuthorizationFault; if !self.effects_enabled || self.lifecycle_deadline.is_some() || !self.granted(SECRET_PROXY_GRANT) { return Err(AuthorizationFault::Capability); } let authority = self .oauth_authority .as_deref() .ok_or(AuthorizationFault::Authority)?; let mut effects = attached_effect_context(&mut self.workspace_effects) .map_err(|_| AuthorizationFault::Authority)?; if !effects.requires_atomic_completion() { return Err(AuthorizationFault::Authority); } effects .begin_nested_redacted("oauth-end-session", "{\"credentials\":\"host-only\"}") .map_err(|_| AuthorizationFault::Storage)?; let result = authority.end_session(&profile.id, &effects.cancel_handle()); let (ok, mutation, evidence) = match result { Ok(true) => ( true, smith::error::MutationState::Applied, "remote revocation confirmed; local tokens cleared", ), Ok(false) => ( true, smith::error::MutationState::Applied, "remote revocation unconfirmed; local tokens cleared", ), Err(fault) => (false, smith::error::MutationState::Unknown, fault.message()), }; if effects .finish_nested_redacted(ok, mutation, evidence) .is_err() { self.fatal_recording_failure.set(true); return Err(AuthorizationFault::Storage); } result.map_err(|fault| authorization_fault(&fault)) } fn renew( &mut self, profile: self::bindings::smith::plugin::secret_proxy::ProfileRef, policy: self::bindings::smith::plugin::secret_proxy::LoginPolicy, ) -> std::result::Result< self::bindings::smith::plugin::secret_proxy::SecretRef, self::bindings::smith::plugin::secret_proxy::AuthorizationFault, > { use self::bindings::smith::plugin::secret_proxy::AuthorizationFault; if !self.effects_enabled || self.lifecycle_deadline.is_some() || !self.granted(SECRET_PROXY_GRANT) { return Err(AuthorizationFault::Capability); } let authority = self .oauth_authority .as_deref_mut() .ok_or(AuthorizationFault::Authority)?; authority .renew_for_dispatch(&profile.id, &oauth_policy(policy)) .map_err(|fault| authorization_fault(&fault))?; Ok(self::bindings::smith::plugin::secret_proxy::SecretRef { id: profile.id }) } fn authorize( &mut self, policy: self::bindings::smith::plugin::secret_proxy::LoginPolicy, ) -> std::result::Result< self::bindings::smith::plugin::secret_proxy::ProfileRef, self::bindings::smith::plugin::secret_proxy::AuthorizationFault, > { effects_enabled(self).map_err(|_| { self::bindings::smith::plugin::secret_proxy::AuthorizationFault::Capability })?; if self.lifecycle_deadline.is_some() || !self.granted(SECRET_PROXY_GRANT) { return Err( self::bindings::smith::plugin::secret_proxy::AuthorizationFault::Capability, ); } let authority = self .oauth_authority .as_deref() .ok_or(self::bindings::smith::plugin::secret_proxy::AuthorizationFault::Authority)?; let policy = oauth_policy(policy); let mut effects = attached_effect_context(&mut self.workspace_effects).map_err(|_| { self::bindings::smith::plugin::secret_proxy::AuthorizationFault::Authority })?; if !effects.requires_atomic_completion() { return Err(self::bindings::smith::plugin::secret_proxy::AuthorizationFault::Authority); } effects .begin_nested_redacted("oauth-authorize", "{\"credentials\":\"host-only\"}") .map_err(|_| { self::bindings::smith::plugin::secret_proxy::AuthorizationFault::Storage })?; let result = authority.authorize(&policy, &effects.cancel_handle()); let (ok, evidence) = match &result { Ok(profile) => (true, profile.id.as_str()), Err(fault) => (false, fault.message()), }; if effects .finish_nested_redacted(ok, smith::error::MutationState::Unknown, evidence) .is_err() { self.fatal_recording_failure.set(true); return Err(self::bindings::smith::plugin::secret_proxy::AuthorizationFault::Storage); } result .map( |profile| self::bindings::smith::plugin::secret_proxy::ProfileRef { id: profile.id, }, ) .map_err(|fault| authorization_fault(&fault)) } fn exchange( &mut self, request: self::bindings::smith::plugin::secret_proxy::CredentialExchange, ) -> std::result::Result { effects_enabled(self)?; if self.lifecycle_deadline.is_some() || !self.granted(SECRET_PROXY_GRANT) { return Err("secret-proxy capability is not granted".to_string()); } let source = request.source.id; let scopes = canonical_secret_scopes(request.scopes); if self.mock_effects.is_some() { let response = mock_effect( self, "credential-exchange", &serde_json::json!({ "source": {"id": source}, "audience": request.audience, "scopes": scopes, }), )?; if response.is_empty() { return Err("fixture secret reference is empty".to_string()); } return Ok(self::bindings::smith::plugin::secret_proxy::SecretRef { id: response }); } let evidence = serde_json::to_string(&serde_json::json!({ "source": format!("secret-ref:{source}"), "audience": request.audience, "scopes": scopes, })) .map_err(|error| error.to_string())?; let evidence = redact_secret_message(&evidence, &self.secret_values); let mut effects = workspace_effect_context(self)?; if !effects.requires_atomic_completion() { return Err("secret exchange requires admitted durable work".to_string()); } effects .begin_nested("secret-exchange", &evidence) .map_err(|error| error.to_string())?; drop(effects); let result = authorized_secret_grant_index(self, &source, &request.audience, &scopes) .and_then(|grant_index| { resolve_exchanged_secret(self, grant_index).map(|()| grant_index) }); match result { Ok(grant_index) => { let id = opaque_secret_ref(&source, grant_index); let binding = redact_secret_message(&id, &self.secret_values); workspace_effect_context(self)? .finish_nested(true, smith::error::MutationState::NotApplied, &binding) .map_err(|error| error.to_string())?; Ok(self::bindings::smith::plugin::secret_proxy::SecretRef { id }) } Err(error) => { workspace_effect_context(self)? .finish_nested(false, smith::error::MutationState::NotApplied, &error) .map_err(|finish| finish.to_string())?; Err(error) } } } } fn canonical_secret_scopes(mut scopes: Vec) -> Vec { scopes.sort(); scopes.dedup(); scopes } fn opaque_secret_ref(source_id: &str, grant_index: usize) -> String { format!("secret-ref:{source_id}:{grant_index}") } fn authorized_secret_grant_index( state: &PluginHostState, source_id: &str, audience: &str, scopes: &[String], ) -> std::result::Result { state .secret_grants .iter() .position(|grant| { grant.source_id == source_id && grant.origin.as_str() == audience && grant.scopes == scopes }) .ok_or_else(|| { "secret exchange exceeds the explicitly granted source, origin, or scopes".to_string() }) } const NET_SCOPE_BYTES_MAX: usize = 1024 * 1024; const NET_SCOPE_TIMEOUT_MS_MAX: u64 = 30_000; const LIFECYCLE_HTTP_BODY_BYTES_MAX: usize = 256; const LIFECYCLE_HTTP_HEADER_BYTES_MAX: usize = 512; const LIFECYCLE_HTTP_HEADER_ITEMS_MAX: usize = 8; const LIFECYCLE_HTTP_ORIGIN_BYTES_MAX: usize = 256; const LIFECYCLE_HTTP_REDACTED_BODY_BYTES_MAX: usize = 7 * 1024; const _: () = assert!( LIFECYCLE_HTTP_REDACTED_BODY_BYTES_MAX * 2 + 1024 <= smith_core::metadata::lifecycle::BYTES_MAX, "hex response plus fixed outcome fields must fit full inline lifecycle evidence" ); // Worst case: one-byte secrets become ten redacted bytes, then hex doubles them. // The 32 MiB logical payload ceiling covers the advertised 1 MiB plus metadata; // physical frames remain bounded, with large evidence in same-ledger chunks. const _: () = assert!( NET_SCOPE_BYTES_MAX * 20 + 4096 <= smith_core::metadata::NESTED_PAYLOAD_BYTES_MAX, "logical payload bound must cover full redacted 1 MiB HTTP bodies plus metadata" ); fn redact_secret_body_hex(bytes: &[u8], secrets: &[String]) -> std::result::Result { let mut sanitizer = crate::response_sanitizer::ResponseSanitizer::new(secrets, b"") .map_err(str::to_string)?; let mut filtered = sanitizer.push(bytes).map_err(str::to_string)?; filtered.extend_from_slice(&sanitizer.finish()); Ok(body_hex(&filtered)) } fn body_hex(bytes: &[u8]) -> String { const HEX: &[u8; 16] = b"0123456789abcdef"; let mut output = String::with_capacity(bytes.len() * 2); for byte in bytes { output.push(char::from(HEX[usize::from(byte >> 4)])); output.push(char::from(HEX[usize::from(byte & 15)])); } output } fn redact_secret_headers( headers: &[smith::http::HttpHeader], secrets: &[String], ) -> Vec { smith::http::redact_headers(headers) .into_iter() .map(|header| smith::http::HttpHeader { name: redact_secret_message(&header.name, secrets), value: redact_secret_message(&header.value, secrets), }) .collect() } fn lifecycle_http_checkpoint( effects: &mut ToolEffectContext<'_>, deadline: Option, allocation_bytes: u64, ) -> std::result::Result<(), String> { if !effects.is_lifecycle() { return Ok(()); } let reason = if effects.cancel_handle().is_cancelled() { Some(smith_core::tools::InvocationStop::Cancelled) } else if deadline.is_some_and(|deadline| std::time::Instant::now() >= deadline) { Some(smith_core::tools::InvocationStop::Deadline) } else { let observed = smith_alloc::AllocationGroup::current() .ok_or_else(|| "lifecycle allocation group unavailable".to_string())? .allocated() .map_err(|_| "lifecycle allocation observation failed".to_string())?; (observed.bytes > allocation_bytes) .then_some(smith_core::tools::InvocationStop::HostAllocation) }; if let Some(reason) = reason { effects.stop(reason); return Err("shared lifecycle HTTP boundary budget stopped".into()); } Ok(()) } #[expect( clippy::too_many_lines, reason = "each HTTP terminal branch synchronously records durable outcome evidence before guest return" )] fn net_scope_request( state: &mut PluginHostState, request: self::bindings::smith::plugin::net_scope::HttpRequest, ) -> std::result::Result { if !state .net_scopes .iter() .any(|scope| scope.as_str() == request.destination) { return Err("net-scope destination is outside the explicitly granted origins".to_string()); } if request.method != "POST" || request.options.timeout_ms == 0 || request.options.timeout_ms > NET_SCOPE_TIMEOUT_MS_MAX || request.options.response_bytes_max == 0 || request.options.response_bytes_max > NET_SCOPE_BYTES_MAX as u64 || request.body.len() > NET_SCOPE_BYTES_MAX { return Err("net-scope request exceeds its explicit host bounds".to_string()); } let response_bytes_max = usize::try_from(request.options.response_bytes_max) .map_err(|_| "net-scope response byte bound exceeds addressable memory".to_string())?; let plugin_id = state.plugin_id.clone(); let mut headers: Vec = request .headers .into_iter() .map(|header| smith::http::HttpHeader { name: header.name, value: header.value, }) .collect(); resolve_secret_headers(state, &request.destination, &mut headers)?; let fatal_recording_failure = &state.fatal_recording_failure; let mut sanitizer = crate::response_sanitizer::ResponseSanitizer::new(&state.secret_values, b"") .map_err(str::to_string)?; let exchange = smith::http::HttpExchange { method: smith::http::HttpMethod::Post, url: request.destination.clone(), headers, body: request.body, }; let secrets = &state.secret_values; let lifecycle_deadline = state.lifecycle_deadline; let lifecycle_allocation_bytes = state.lifecycle_allocation_bytes; let mut effects = attached_effect_context(&mut state.workspace_effects)?; lifecycle_http_checkpoint(&mut effects, lifecycle_deadline, lifecycle_allocation_bytes)?; let lifecycle = effects.is_lifecycle(); if lifecycle && (request.options.response_bytes_max > LIFECYCLE_HTTP_BODY_BYTES_MAX as u64 || exchange.body.len() > LIFECYCLE_HTTP_BODY_BYTES_MAX || exchange.url.len() > LIFECYCLE_HTTP_ORIGIN_BYTES_MAX || exchange.headers.len() > LIFECYCLE_HTTP_HEADER_ITEMS_MAX || exchange .headers .iter() .map(|header| header.name.len() + header.value.len()) .sum::() > LIFECYCLE_HTTP_HEADER_BYTES_MAX) { return Err("lifecycle HTTP exceeds full inline evidence bounds".into()); } let durable = effects.requires_atomic_completion() || lifecycle; if durable { let mut headers = redact_secret_headers(&exchange.headers, secrets); let mut origin = redact_secret_message(&exchange.url, secrets); let request_body = if lifecycle { for header in &mut headers { header.name = String::from_utf8( effects .redact_lifecycle_bytes(header.name.as_bytes()) .map_err(|error| error.to_string())?, ) .map_err(|_| "redacted header name is not UTF-8")?; header.value = String::from_utf8( effects .redact_lifecycle_bytes(header.value.as_bytes()) .map_err(|error| error.to_string())?, ) .map_err(|_| "redacted header value is not UTF-8")?; } origin = String::from_utf8( effects .redact_lifecycle_bytes(origin.as_bytes()) .map_err(|error| error.to_string())?, ) .map_err(|_| "redacted origin is not UTF-8")?; Some( effects .redact_lifecycle_bytes(&exchange.body) .map_err(|error| error.to_string())?, ) } else { None }; let evidence = serde_json::json!({ "origin": origin, "method": "POST", "headers": headers, "body_hex": redact_secret_body_hex(request_body.as_deref().unwrap_or(&exchange.body), secrets)?, "timeout_ms": request.options.timeout_ms, "response_bytes_max": request.options.response_bytes_max, }) .to_string(); effects .begin_nested_redacted("http", &evidence) .map_err(|error| error.to_string())?; } else { let call_id = effects .call_id() .ok_or_else(|| "net-scope requires model tool identity".to_string())?; effects .record_plugin_http(&smith::http::PluginHttpEffectRecord::Intent { plugin_id, call_id, origin: redact_secret_message(&request.destination, secrets), method: exchange.method, headers: redact_secret_headers(&exchange.headers, secrets).into(), request_bytes: exchange.body.len(), timeout_ms: request.options.timeout_ms, response_bytes_max: request.options.response_bytes_max, }) .map_err(|error| error.to_string())?; } if let Err(error) = lifecycle_http_checkpoint(&mut effects, lifecycle_deadline, lifecycle_allocation_bytes) { effects .finish_nested_redacted( false, smith::error::MutationState::NotApplied, "{\"failure\":\"boundary-stopped-before-transport\"}", ) .map_err(|error| error.to_string())?; return Err(error); } let response_bytes = Cell::new(0_usize); let record_outcome = |effects: &mut ToolEffectContext<'_>, status, body: &[u8], outcome, error: &str| { let result = if durable { let redacted_body = if lifecycle { Some(effects.redact_lifecycle_bytes(body)) } else { None }; if redacted_body.as_ref().is_some_and(|body| { body.as_ref().map_or(true, |body| { body.len() > LIFECYCLE_HTTP_REDACTED_BODY_BYTES_MAX }) }) { effects .finish_nested_redacted( false, if outcome == smith::http::PluginHttpEffectOutcome::Completed { smith::error::MutationState::Applied } else { smith::error::MutationState::Unknown }, "{\"failure\":\"inline-response-bound-exceeded\"}", ) .map_err(|error| { fatal_recording_failure.set(true); error.to_string() })?; return Err("lifecycle response redaction exceeds inline evidence bound".into()); } let redacted_body = redacted_body .transpose() .map_err(|error| error.to_string())?; let output = serde_json::json!({ "status": status, "body_hex": body_hex(redacted_body.as_deref().unwrap_or(body)), "outcome": outcome, "error": redact_secret_message(error, secrets), }) .to_string(); let ok = outcome == smith::http::PluginHttpEffectOutcome::Completed; effects.finish_nested_redacted( ok, if ok { smith::error::MutationState::Applied } else { smith::error::MutationState::Unknown }, &output, ) } else { effects.record_plugin_http(&smith::http::PluginHttpEffectRecord::Outcome { status, response_bytes: u64::try_from(response_bytes.get()).unwrap_or(u64::MAX), outcome, }) }; result.map_err(|error| { fatal_recording_failure.set(true); error.to_string() })?; lifecycle_http_checkpoint(effects, lifecycle_deadline, lifecycle_allocation_bytes) }; if effects.cancel_handle().is_cancelled() { if durable { effects .finish_nested( false, smith::error::MutationState::NotApplied, "HTTP cancelled before dispatch", ) .map_err(|error| error.to_string())?; } else { record_outcome( &mut effects, 0, &[], smith::http::PluginHttpEffectOutcome::Cancelled, "net-scope request cancelled", )?; } return Err("net-scope request cancelled".to_string()); } let timeout = std::time::Duration::from_millis(request.options.timeout_ms); let timeout = state.lifecycle_deadline.map_or(timeout, |deadline| { timeout.min(deadline.saturating_duration_since(std::time::Instant::now())) }); let executor = if lifecycle { crate::http::UreqHttpExecutor::lifecycle( timeout, &effects.cancel_handle(), request.options.response_bytes_max, ) } else { crate::http::UreqHttpExecutor::with_timeouts(timeout, timeout) }; let Ok(response) = executor.execute(exchange, effects.cancel_handle()) else { let outcome = if effects.cancel_handle().is_cancelled() { smith::http::PluginHttpEffectOutcome::Cancelled } else { smith::http::PluginHttpEffectOutcome::Failed }; record_outcome( &mut effects, 0, &[], outcome, "net-scope HTTP dispatch failed", )?; return Err("net-scope HTTP dispatch failed".to_string()); }; let status = response.head.status; let mut body = Vec::new(); for item in response.body { match item { smith::http::HttpBodyItem::Chunk(chunk) => { let Some(length) = response_bytes.get().checked_add(chunk.bytes.len()) else { record_outcome( &mut effects, status, &body, smith::http::PluginHttpEffectOutcome::Failed, "net-scope response byte count overflowed", )?; return Err("net-scope response byte count overflowed".to_string()); }; if length > response_bytes_max { record_outcome( &mut effects, status, &body, smith::http::PluginHttpEffectOutcome::Failed, "net-scope response exceeds its explicit byte bound", )?; return Err("net-scope response exceeds its explicit byte bound".to_string()); } response_bytes.set(length); match sanitizer.push(&chunk.bytes) { Ok(filtered) => body.extend_from_slice(&filtered), Err(message) => { record_outcome( &mut effects, status, &body, smith::http::PluginHttpEffectOutcome::Failed, message, )?; return Err(message.to_string()); } } } smith::http::HttpBodyItem::End(smith::http::HttpBodyEnd::Complete) => { if effects.cancel_handle().is_cancelled() { record_outcome( &mut effects, status, &body, smith::http::PluginHttpEffectOutcome::Cancelled, "net-scope request cancelled", )?; return Err("net-scope request cancelled".to_string()); } body.extend_from_slice(&sanitizer.finish()); record_outcome( &mut effects, status, &body, smith::http::PluginHttpEffectOutcome::Completed, "", )?; return Ok(self::bindings::smith::plugin::net_scope::HttpResponse { status, headers: Vec::new(), body, }); } smith::http::HttpBodyItem::End(smith::http::HttpBodyEnd::Cancelled) => { record_outcome( &mut effects, status, &body, smith::http::PluginHttpEffectOutcome::Cancelled, "net-scope request cancelled", )?; return Err("net-scope request cancelled".to_string()); } smith::http::HttpBodyItem::End(smith::http::HttpBodyEnd::Truncated { .. }) => { record_outcome( &mut effects, status, &body, smith::http::PluginHttpEffectOutcome::Failed, "net-scope response exceeds the host byte bound", )?; return Err("net-scope response exceeds the host byte bound".to_string()); } smith::http::HttpBodyItem::End(smith::http::HttpBodyEnd::Failed { message: _ }) => { record_outcome( &mut effects, status, &body, smith::http::PluginHttpEffectOutcome::Failed, "net-scope response failed", )?; return Err("net-scope response failed".to_string()); } } } record_outcome( &mut effects, status, &body, smith::http::PluginHttpEffectOutcome::Failed, "net-scope response ended without a terminal outcome", )?; Err("net-scope response ended without a terminal outcome".to_string()) } fn resolve_exchanged_secret( state: &mut PluginHostState, grant_index: usize, ) -> std::result::Result<(), String> { if state .resolved_secret_refs .iter() .any(|reference| reference.grant_index == grant_index) { return Ok(()); } if state.resolved_secret_refs.len() == RESOLVED_SECRET_REFS_MAX { return Err("resolved secret reference bound exceeded".to_string()); } let grant = state .secret_grants .get(grant_index) .ok_or_else(|| "secret exchange grant disappeared before resolution".to_string())?; let secret = grant .credential .resolve(&grant.auth_store) .map_err(|error| error.to_string())?; let secret_value_index = if let Some(index) = state .secret_values .iter() .position(|value| value == &secret) { index } else { state.secret_values.push(secret); if let Err(message) = crate::response_sanitizer::ResponseSanitizer::validate(&state.secret_values) { state.secret_values.pop(); return Err(message.to_string()); } state.secret_values.len() - 1 }; let secret_value_index = u8::try_from(secret_value_index) .map_err(|_| "resolved secret value index overflowed its bound".to_string())?; state.resolved_secret_refs.push(ResolvedSecretRef { grant_index, secret_value_index, }); Ok(()) } fn resolve_secret_headers( state: &PluginHostState, destination: &str, headers: &mut [smith::http::HttpHeader], ) -> std::result::Result<(), String> { for header in headers { let Some(reference) = header .value .strip_prefix("{{secret:") .and_then(|value| value.strip_suffix("}}")) else { continue; }; let resolved = state .resolved_secret_refs .iter() .find(|resolved| { state .secret_grants .get(resolved.grant_index) .is_some_and(|grant| { opaque_secret_ref(&grant.source_id, resolved.grant_index) == reference }) }) .ok_or_else(|| "secret reference was not exchanged before HTTP dispatch".to_string())?; let grant = state .secret_grants .get(resolved.grant_index) .ok_or_else(|| "secret exchange grant disappeared before HTTP dispatch".to_string())?; if grant.origin.as_str() != destination || !grant.scopes.iter().any(|scope| scope == "http-request") { return Err( "secret reference is not granted for this HTTP origin and scope".to_string(), ); } header.value = state .secret_values .get(usize::from(resolved.secret_value_index)) .cloned() .ok_or_else(|| "resolved secret value disappeared before HTTP dispatch".to_string())?; } Ok(()) } fn mock_http_response( response: &str, ) -> std::result::Result { let response: serde_json::Value = serde_json::from_str(response) .map_err(|error| format!("fixture HTTP response is invalid: {error}"))?; let status = response .get("status") .and_then(serde_json::Value::as_u64) .and_then(|status| u16::try_from(status).ok()) .ok_or_else(|| "fixture HTTP response has invalid status".to_string())?; let headers = response .get("headers") .and_then(serde_json::Value::as_array) .ok_or_else(|| "fixture HTTP response has invalid headers".to_string())? .iter() .map( |header| -> std::result::Result< self::bindings::smith::plugin::net_scope::Header, String, > { let name = header .get("name") .and_then(serde_json::Value::as_str) .ok_or_else(|| { "fixture HTTP response header has invalid name".to_string() })?; let value = header .get("value") .and_then(serde_json::Value::as_str) .ok_or_else(|| { "fixture HTTP response header has invalid value".to_string() })?; Ok(self::bindings::smith::plugin::net_scope::Header { name: name.to_string(), value: value.to_string(), }) }, ) .collect::, _>>()?; let body = response .get("body") .and_then(serde_json::Value::as_array) .ok_or_else(|| "fixture HTTP response has invalid body".to_string())? .iter() .map(|byte| { byte.as_u64() .and_then(|byte| u8::try_from(byte).ok()) .ok_or_else(|| "fixture HTTP response body has invalid byte".to_string()) }) .collect::, _>>()?; Ok(self::bindings::smith::plugin::net_scope::HttpResponse { status, headers, body, }) } impl ToolingHost for PluginHostState { fn read( &mut self, request: self::bindings::smith::plugin::tooling::FileRead, ) -> std::result::Result { let text = workspace_effect( self, "read", &serde_json::json!({"path": request.path, "offset": request.offset, "limit": request.limit, "max_bytes": request.max_bytes}), )?; Ok(self::bindings::smith::plugin::tooling::FileContent { text }) } fn write( &mut self, request: self::bindings::smith::plugin::tooling::FileWrite, ) -> std::result::Result<(), String> { workspace_effect( self, "write", &serde_json::json!({"path": request.path, "content": request.content}), ) .map(|_| ()) } fn edit( &mut self, request: self::bindings::smith::plugin::tooling::FileEdit, ) -> std::result::Result<(), String> { workspace_effect(self, "edit", &serde_json::json!({"path": request.path, "old_string": request.old_text, "new_string": request.new_text})).map(|_| ()) } fn list_directory( &mut self, request: self::bindings::smith::plugin::tooling::DirectoryQuery, ) -> std::result::Result, String> { directory_effect(self, "ls", request) } fn find( &mut self, request: self::bindings::smith::plugin::tooling::DirectoryQuery, ) -> std::result::Result, String> { directory_effect(self, "find", request) } fn grep( &mut self, request: self::bindings::smith::plugin::tooling::DirectoryQuery, ) -> std::result::Result, String> { directory_effect(self, "grep", request) } fn run_command( &mut self, request: self::bindings::smith::plugin::tooling::CommandRequest, ) -> std::result::Result { process_effect( self, "bash", &serde_json::json!({"command": request.text, "timeout_ms": request.timeout_ms}), ) } } fn directory_effect( state: &mut PluginHostState, tool: &str, request: self::bindings::smith::plugin::tooling::DirectoryQuery, ) -> std::result::Result, String> { let path = request.path; let output = match tool { "ls" => workspace_effect(state, tool, &serde_json::json!({"path": path}))?, "find" => workspace_effect( state, tool, &serde_json::json!({"path": path, "pattern": request.pattern.unwrap_or_default()}), )?, "grep" => workspace_effect( state, tool, &serde_json::json!({"path": path, "query": request.pattern.unwrap_or_default()}), )?, _ => return Err("invalid workspace directory operation".to_string()), }; Ok(output.lines().map(str::to_string).collect()) } fn workspace_effect( state: &mut PluginHostState, tool: &str, input: &serde_json::Value, ) -> std::result::Result { effects_enabled(state)?; if !state.granted(WORKSPACE_GRANT) { return Err("workspace capability is not granted".to_string()); } if state.mock_effects.is_some() { return mock_effect(state, tool, input); } let arguments = smith::structured::ToolArguments::from_serializable(&input) .map_err(|error| format!("invalid workspace arguments: {error}"))?; let secrets = &state.secret_values; attached_effect_context(&mut state.workspace_effects)? .invoke_redacted(tool, &arguments, |text| { redact_secret_message(text, secrets) }) .map_err(|error| error.to_string()) } fn process_effect( state: &mut PluginHostState, tool: &str, input: &serde_json::Value, ) -> std::result::Result { effects_enabled(state)?; if !state.granted(PROCESS_GRANT) { return Err("process capability is not granted".to_string()); } if state.mock_effects.is_some() { return mock_effect(state, tool, input); } let arguments = smith::structured::ToolArguments::from_serializable(&input) .map_err(|error| format!("invalid process arguments: {error}"))?; let secrets = &state.secret_values; attached_effect_context(&mut state.workspace_effects)? .invoke_redacted(tool, &arguments, |text| { redact_secret_message(text, secrets) }) .map_err(|error| error.to_string()) } fn mock_effect( state: &mut PluginHostState, operation: &str, request: &serde_json::Value, ) -> std::result::Result { let request_json = serde_json::to_string(request) .map_err(|error| format!("fixture request serialization failed: {error}"))?; let effects = state .mock_effects .as_mut() .ok_or_else(|| "mock effect context is not configured".to_string())?; let index = effects.trace.len(); let Some(plan) = effects.plans.get(index) else { return Err(format!( "unexpected fixture effect {operation} {request_json}" )); }; if plan.operation != operation || plan.request_json != request_json { return Err(format!( "fixture effect {index} differs: expected {} {}, got {operation} {request_json}", plan.operation, plan.request_json )); } effects.trace.push(plan.clone()); Ok(plan.response.clone()) } /// Owns a stable attachment for exactly one synchronous guest call. fn attach_workspace_effects( store: &Store, effects: &mut ToolEffectContext<'_>, ) -> Result { store .data() .workspace_effects .attach(std::ptr::from_mut(effects).cast()) } fn workspace_effect_context( state: &mut PluginHostState, ) -> std::result::Result, String> { attached_effect_context(&mut state.workspace_effects) } /// Suspension owns the only accessible context pointer while a host import runs. /// A child may attach an exclusive reborrow to another store only inside this lease. struct ScopedEffectContext<'attachment> { suspension: attachment::Suspension, lifetime: std::marker::PhantomData<&'attachment mut WorkspaceEffects>, } #[expect( unsafe_code, reason = "the suspended import lease bounds the shared context reborrow" )] impl<'attachment> std::ops::Deref for ScopedEffectContext<'attachment> { type Target = ToolEffectContext<'attachment>; fn deref(&self) -> &Self::Target { // SAFETY: the root call owns the live context; suspension removes parent access. // This reference cannot outlive the import lease, which restores the attachment. unsafe { &*self.suspension.effects().cast() } } } #[expect( unsafe_code, reason = "the suspended import lease bounds the exclusive context reborrow" )] impl std::ops::DerefMut for ScopedEffectContext<'_> { fn deref_mut(&mut self) -> &mut Self::Target { // SAFETY: only this suspended lease can access the context; &mut self serializes // reborrows. Any child attachment must drop before its reborrow returns here. unsafe { &mut *self.suspension.effects().cast() } } } fn attached_effect_context( attachment: &mut WorkspaceEffects, ) -> std::result::Result, String> { Ok(ScopedEffectContext { suspension: attachment.suspend()?, lifetime: std::marker::PhantomData, }) } #[cfg(test)] mod nested_tests; #[cfg(test)] mod tests { //! Runtime limiter tests (`SMH-SPEC-WASM0001`). use super::*; #[test] fn nested_http_binary_evidence_preserves_bytes_without_credential_encodings() { assert_eq!(redact_secret_body_hex(&[0, 255], &[]).unwrap(), "00ff"); assert_eq!( redact_secret_body_hex(b"\xfftoken\0", &["token".into()]).unwrap(), "ff3c72656461637465643e00" ); let largest = vec![0; NET_SCOPE_BYTES_MAX]; let encoded = redact_secret_body_hex(&largest, &["\0".into()]).unwrap(); assert!(encoded.len() + 4096 <= smith_core::metadata::NESTED_PAYLOAD_BYTES_MAX); } #[test] fn registered_secrets_are_redacted_inside_json_keys_values_results_and_errors() { let secret = "credential\"with\ncontrol\\bytes".to_string(); let serialized = serde_json::to_string(&serde_json::json!({secret.clone(): secret})).unwrap(); let redacted = redact_secret_message(&serialized, std::slice::from_ref(&secret)); assert_eq!(redacted, r#"{"":""}"#); assert_eq!( redact_secret_message(&format!("result or error: {secret}"), &[secret]), "result or error: " ); } #[test] fn pure_attachment_reborrow_uses_live_context_provenance() { let mut session = smith_core::tools::ToolSession::new(std::env::temp_dir()); let mut effects = ToolEffectContext::for_operation(&mut session, "write"); let mut attachment = WorkspaceEffects::default(); let _outer = attachment .attach(std::ptr::from_mut(&mut effects).cast()) .unwrap(); { let mut parent = attached_effect_context(&mut attachment).unwrap(); assert!(parent.call_id().is_none()); let mut child_attachment = WorkspaceEffects::default(); let _child = child_attachment .attach(std::ptr::from_mut(&mut *parent).cast()) .unwrap(); { let mut child = attached_effect_context(&mut child_attachment).unwrap(); child.stop(smith_core::tools::InvocationStop::Fuel); assert!(child.cancel_handle().is_cancelled()); } assert!(parent.cancel_handle().is_cancelled()); } assert!(attachment.get().is_some()); attachment.set(None); assert!(attached_effect_context(&mut attachment).is_err()); } #[test] fn scoped_workspace_effect_context_clears_after_unwind_and_rejects_reentry() { let engine = PluginEngine::new().unwrap(); let store = Store::new( engine.engine(), PluginHostState { composition: None, memory_bytes: 0, table_elements: 0, sealed_handles: 0, monotonic_now: 0, ceilings: PluginCeilings::default(), grants: WORKSPACE_GRANT, effects_enabled: true, lifecycle_deadline: None, lifecycle_allocation_bytes: 0, plugin_id: String::new(), net_scopes: Vec::new(), secret_grants: Vec::new(), oauth_authority: None, workspace_effects: WorkspaceEffects::default(), fatal_recording_failure: Cell::new(false), log_bytes: 0, log_entries: Vec::new(), secret_values: Vec::new(), resolved_secret_refs: Vec::new(), mock_effects: None, }, ); let mut effect_context = (); let address = std::ptr::from_mut(&mut effect_context).cast(); let unwind = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { let _scope = store.data().workspace_effects.attach(address).unwrap(); assert!(store.data().workspace_effects.attach(address).is_err()); panic!("test unwind"); })); assert!(unwind.is_err()); assert!(store.data().workspace_effects.get().is_none()); let _scope = store.data().workspace_effects.attach(address).unwrap(); } #[test] fn registered_generation_replacement_keeps_advertised_provenance_hash_pinned() { let dir = std::env::temp_dir().join(format!( "smith-generation-provenance-{}", std::process::id() )); std::fs::create_dir_all(&dir).unwrap(); let first = load_coding_tools(&dir).unwrap().generation; let expected_manifest = smith::sha256::digest_hex(b"smith:coding-tools"); let expected_component = smith::sha256::digest_hex(CODING_TOOLS_COMPONENT); let mut registry = PluginRegistry::default(); registry.publish(first); let pinned = registry.snapshot().unwrap(); assert_eq!(pinned.provenance.components.len(), 1); assert_eq!( pinned.provenance.components[0].source_id, "smith:coding-tools" ); assert_eq!( pinned.provenance.components[0].manifest_sha256, expected_manifest ); assert_eq!( pinned.provenance.components[0].component_sha256, expected_component ); let replacement = load_coding_tools(&dir).unwrap().generation; registry.publish(replacement); assert_eq!(pinned, registry.snapshot().unwrap()); assert_eq!( pinned.provenance.components[0].manifest_sha256, expected_manifest ); assert_eq!( pinned.provenance.components[0].component_sha256, expected_component ); std::fs::remove_dir_all(dir).unwrap(); } #[test] fn artifact_validation_allows_plugin_world_and_rejects_other_smith_contracts() { validate_declared_limits(CODING_TOOLS_COMPONENT).unwrap(); let mut malicious = CODING_TOOLS_COMPONENT.to_vec(); let required = b"smith:plugin/plugin@0.1.0"; let malicious_name = b"smith:attaxx/plugin@0.1.0"; assert_eq!(required.len(), malicious_name.len()); let offsets: Vec = malicious .windows(required.len()) .enumerate() .filter_map(|(offset, window)| (window == required).then_some(offset)) .collect(); assert!( !offsets.is_empty(), "coding component exports the required plugin contract" ); for offset in offsets { malicious[offset..offset + required.len()].copy_from_slice(malicious_name); if let Err(error) = validate_declared_limits(&malicious) && error.to_string().contains("reserved Smith contract") { return; } malicious[offset..offset + required.len()].copy_from_slice(required); } panic!("wasmparser did not expose the malicious Smith export"); } #[test] fn admitted_guest_workspace_effects_require_an_outer_call_scope() { let dir = std::env::temp_dir().join(format!( "smith-admitted-nested-grants-{}", std::process::id() )); std::fs::create_dir_all(&dir).unwrap(); let mut runtime = load_coding_tools(&dir).unwrap(); for capability in ["net-scope", "log"] { runtime.generation.manifest = PluginManifest::parse(&format!( "id \"smith:coding-tools\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"fixture.wasm\"\ncapability \"workspace\"\ncapability \"{capability}\"" )).unwrap(); let mut tools = smith_core::tools::ToolSession::new(&dir) .with_completion_boundary(smith::id::EntryId::new(), |_| Ok(())); let mut effects = ToolEffectContext::for_operation(&mut tools, "write"); let error = runtime .generation .invoke_with_effects( "write", r#"{"path":"never.txt","content":"not authorized"}"#, &mut effects, ) .unwrap_err(); assert!(error.to_string().contains("requires an outer call")); assert!(!dir.join("never.txt").exists()); assert!(tools.session.active_branch().entries().is_empty()); } std::fs::remove_dir_all(dir).unwrap(); } #[test] fn filesystem_only_grant_cannot_invoke_process_import() { let mut state = PluginHostState { composition: None, memory_bytes: 0, table_elements: 0, sealed_handles: 0, monotonic_now: 0, ceilings: PluginCeilings::default(), grants: WORKSPACE_GRANT, effects_enabled: true, lifecycle_deadline: None, lifecycle_allocation_bytes: 0, plugin_id: String::new(), net_scopes: Vec::new(), secret_grants: Vec::new(), oauth_authority: None, workspace_effects: WorkspaceEffects::default(), fatal_recording_failure: Cell::new(false), log_bytes: 0, log_entries: Vec::new(), secret_values: Vec::new(), resolved_secret_refs: Vec::new(), mock_effects: None, }; let error = process_effect( &mut state, "bash", &serde_json::json!({"command": "true", "timeout_ms": 1}), ) .unwrap_err(); assert_eq!(error, "process capability is not granted"); } fn secret_grant(source_id: &str, origin: &str, scopes: &[&str], secret: &str) -> SecretGrant { SecretGrant { source_id: source_id.to_string(), origin: NetScope::parse(origin).unwrap(), scopes: scopes.iter().map(|scope| (*scope).to_string()).collect(), credential: CredentialReference::explicit(secret), auth_store: AuthStore::at(std::env::temp_dir()), } } fn secret_proxy_state(secret_grants: Vec) -> PluginHostState { PluginHostState { composition: None, memory_bytes: 0, table_elements: 0, sealed_handles: 0, monotonic_now: 0, ceilings: PluginCeilings::default(), grants: SECRET_PROXY_GRANT, effects_enabled: true, lifecycle_deadline: None, lifecycle_allocation_bytes: 0, plugin_id: String::new(), net_scopes: Vec::new(), secret_grants, oauth_authority: None, workspace_effects: WorkspaceEffects::default(), fatal_recording_failure: Cell::new(false), log_bytes: 0, log_entries: Vec::new(), secret_values: Vec::new(), resolved_secret_refs: Vec::new(), mock_effects: None, } } #[test] fn oauth_authority_requires_capability_registration_phase_and_durable_admission() { use crate::oauth::{LoginAuthority, LoginPolicy, ProfileStore}; let root = std::env::temp_dir().join(format!("oauth-unadmitted-{}", smith::id::SessionId::new())); let policy = LoginPolicy { flow: crate::oauth::LoginFlow::DynamicOidc, connection_id: "openai-chatgpt-plan".into(), token_origin: "https://issuer.example".into(), issuer: "https://issuer.example".into(), resource: "https://resource.example/v1".into(), initial_client: "dynamic_agent_client".into(), issued_prefix: "oaiapp_".into(), authorization_path: "/authorize".into(), token_path: "/token".into(), agent_name: "Fixture".into(), scopes: vec!["openid".into()], required_scopes: vec!["openid".into()], }; let request = self::bindings::smith::plugin::secret_proxy::LoginPolicy { flow: self::bindings::smith::plugin::secret_proxy::LoginFlow::DynamicOidc, connection_id: policy.connection_id.clone(), token_origin: policy.token_origin.clone(), issuer: policy.issuer.clone(), audience: policy.resource.clone(), initial_client: policy.initial_client.clone(), issued_prefix: policy.issued_prefix.clone(), authorization_path: policy.authorization_path.clone(), token_path: policy.token_path.clone(), agent_name: policy.agent_name.clone(), scopes: policy.scopes.clone(), required_scopes: policy.required_scopes.clone(), }; let mut state = secret_proxy_state(Vec::new()); state.oauth_authority = Some(Box::new( LoginAuthority::new(policy, ProfileStore::at(root.clone())).unwrap(), )); state.grants = 0; assert!(matches!( SecretProxyHost::authorize(&mut state, request.clone()).unwrap_err(), self::bindings::smith::plugin::secret_proxy::AuthorizationFault::Capability )); state.grants = SECRET_PROXY_GRANT; state.effects_enabled = false; assert!(matches!( SecretProxyHost::authorize(&mut state, request.clone()).unwrap_err(), self::bindings::smith::plugin::secret_proxy::AuthorizationFault::Capability )); state.effects_enabled = true; let mut tools = smith_core::tools::ToolSession::new(std::env::temp_dir()); let mut effects = ToolEffectContext::for_operation(&mut tools, "login"); state .workspace_effects .set(Some(std::ptr::from_mut(&mut effects).cast())); assert!(matches!( SecretProxyHost::authorize(&mut state, request).unwrap_err(), self::bindings::smith::plugin::secret_proxy::AuthorizationFault::Authority )); state.workspace_effects.set(None); assert!(!root.exists()); } #[test] fn secret_proxy_exchanges_only_opaque_fixture_references() { let mut state = PluginHostState { composition: None, memory_bytes: 0, table_elements: 0, sealed_handles: 0, monotonic_now: 0, ceilings: PluginCeilings::default(), grants: SECRET_PROXY_GRANT, effects_enabled: true, lifecycle_deadline: None, lifecycle_allocation_bytes: 0, plugin_id: String::new(), net_scopes: Vec::new(), secret_grants: Vec::new(), oauth_authority: None, workspace_effects: WorkspaceEffects::default(), fatal_recording_failure: Cell::new(false), log_bytes: 0, log_entries: Vec::new(), secret_values: Vec::new(), resolved_secret_refs: Vec::new(), mock_effects: Some(MockEffects { plans: vec![MockEffectPlan { operation: "credential-exchange".to_string(), request_json: r#"{"source":{"id":"stored"},"audience":"loopback","scopes":["read"]}"# .to_string(), response: "derived".to_string(), }], trace: Vec::new(), }), }; let reference = SecretProxyHost::exchange( &mut state, self::bindings::smith::plugin::secret_proxy::CredentialExchange { source: self::bindings::smith::plugin::secret_proxy::SecretRef { id: "stored".to_string(), }, audience: "loopback".to_string(), scopes: vec!["read".to_string()], }, ) .unwrap(); assert_eq!(reference.id, "derived"); } #[test] fn secret_proxy_rejects_exchange_without_durable_intent_before_secret_resolution() { let origin = NetScope::parse("https://api.example.test").unwrap(); let mut state = PluginHostState { composition: None, memory_bytes: 0, table_elements: 0, sealed_handles: 0, monotonic_now: 0, ceilings: PluginCeilings::default(), grants: SECRET_PROXY_GRANT, effects_enabled: true, lifecycle_deadline: None, lifecycle_allocation_bytes: 0, plugin_id: String::new(), net_scopes: Vec::new(), secret_grants: vec![ SecretGrant { source_id: "anthropic".to_string(), origin, scopes: vec!["http-request".to_string()], credential: CredentialReference::explicit("selected-secret"), auth_store: AuthStore::at(std::env::temp_dir()), }, SecretGrant { source_id: "unused-missing".to_string(), origin: NetScope::parse("https://unused.example.test").unwrap(), scopes: vec!["http-request".to_string()], credential: CredentialReference::explicit(String::new()), auth_store: AuthStore::at(std::env::temp_dir()), }, ], oauth_authority: None, workspace_effects: WorkspaceEffects::default(), fatal_recording_failure: Cell::new(false), log_bytes: 0, log_entries: Vec::new(), secret_values: Vec::new(), resolved_secret_refs: Vec::new(), mock_effects: None, }; let exchange = |state: &mut PluginHostState, source: &str, audience: &str| { SecretProxyHost::exchange( state, self::bindings::smith::plugin::secret_proxy::CredentialExchange { source: self::bindings::smith::plugin::secret_proxy::SecretRef { id: source.to_string(), }, audience: audience.to_string(), scopes: vec!["http-request".to_string()], }, ) }; assert!(exchange(&mut state, "anthropic", "https://api.example.test").is_err()); assert!(state.secret_values.is_empty()); assert!(state.resolved_secret_refs.is_empty()); assert!(exchange(&mut state, "other", "https://api.example.test").is_err()); assert!(exchange(&mut state, "anthropic", "https://other.example.test").is_err()); } #[test] fn secret_proxy_rejects_nonadmitted_and_failed_durable_intents_before_resolution() { let grants = vec![secret_grant( "provider", "https://api.example.test", &["http-request"], "selected-secret", )]; let request = self::bindings::smith::plugin::secret_proxy::CredentialExchange { source: self::bindings::smith::plugin::secret_proxy::SecretRef { id: "provider".to_string(), }, audience: "https://api.example.test".to_string(), scopes: vec!["http-request".to_string()], }; let directory = std::env::temp_dir(); let mut tools = smith_core::tools::ToolSession::new(&directory); let mut effects = ToolEffectContext::for_operation(&mut tools, "fixture"); let mut state = secret_proxy_state(grants.clone()); state .workspace_effects .set(Some(std::ptr::from_mut(&mut effects).cast())); assert!(SecretProxyHost::exchange(&mut state, request.clone()).is_err()); state.workspace_effects.set(None); assert!(state.secret_values.is_empty()); assert!(state.resolved_secret_refs.is_empty()); let mut tools = smith_core::tools::ToolSession::new(&directory) .with_completion_boundary(smith::id::EntryId::new(), |_| Ok(())); let mut effects = ToolEffectContext::for_operation(&mut tools, "fixture"); let mut state = secret_proxy_state(grants); state .workspace_effects .set(Some(std::ptr::from_mut(&mut effects).cast())); assert!(SecretProxyHost::exchange(&mut state, request).is_err()); state.workspace_effects.set(None); assert!(state.secret_values.is_empty()); assert!(state.resolved_secret_refs.is_empty()); } #[test] fn secret_headers_bind_each_opaque_reference_to_its_authorized_grant() { let mut state = secret_proxy_state(vec![ secret_grant( "provider", "https://first.example.test", &["http-request"], "first-secret", ), secret_grant( "provider", "https://second.example.test", &["http-request"], "second-secret", ), secret_grant( "provider", "https://first.example.test", &["other"], "third-secret", ), ]); assert_eq!( authorized_secret_grant_index( &state, "provider", "https://first.example.test", &["http-request".to_string()], ) .unwrap(), 0 ); assert_eq!( authorized_secret_grant_index( &state, "provider", "https://second.example.test", &["http-request".to_string()], ) .unwrap(), 1 ); assert_eq!( authorized_secret_grant_index( &state, "provider", "https://first.example.test", &["other".to_string()], ) .unwrap(), 2 ); resolve_exchanged_secret(&mut state, 0).unwrap(); let mut headers = [smith::http::HttpHeader { name: "authorization".to_string(), value: "{{secret:secret-ref:provider:0}}".to_string(), }]; resolve_secret_headers(&state, "https://first.example.test", &mut headers).unwrap(); assert_eq!(headers[0].value, "first-secret"); let mut wrong_origin = [smith::http::HttpHeader { name: "authorization".to_string(), value: "{{secret:secret-ref:provider:0}}".to_string(), }]; assert!( resolve_secret_headers(&state, "https://second.example.test", &mut wrong_origin) .is_err() ); let mut unexchanged = [smith::http::HttpHeader { name: "authorization".to_string(), value: "{{secret:secret-ref:provider:1}}".to_string(), }]; assert!( resolve_secret_headers(&state, "https://second.example.test", &mut unexchanged) .is_err() ); } #[test] fn resolved_secret_references_cap_aliases_without_copying_credentials() { let grants = (0..=RESOLVED_SECRET_REFS_MAX) .map(|index| { secret_grant( &format!("alias-{index}"), "https://api.example.test", &["http-request"], "shared-secret", ) }) .collect(); let mut state = secret_proxy_state(grants); for index in 0..RESOLVED_SECRET_REFS_MAX { resolve_exchanged_secret(&mut state, index).unwrap(); } assert_eq!(state.resolved_secret_refs.len(), RESOLVED_SECRET_REFS_MAX); assert_eq!(state.secret_values, ["shared-secret"]); assert!(resolve_exchanged_secret(&mut state, RESOLVED_SECRET_REFS_MAX).is_err()); assert_eq!(state.resolved_secret_refs.len(), RESOLVED_SECRET_REFS_MAX); assert_eq!(state.secret_values, ["shared-secret"]); } #[test] fn log_capability_redacts_header_tokens_and_enforces_invocation_bound() { let mut state = PluginHostState { composition: None, memory_bytes: 0, table_elements: 0, sealed_handles: 0, monotonic_now: 0, ceilings: PluginCeilings::default(), grants: LOG_GRANT, effects_enabled: true, lifecycle_deadline: None, lifecycle_allocation_bytes: 0, plugin_id: String::new(), net_scopes: Vec::new(), secret_grants: Vec::new(), oauth_authority: None, workspace_effects: WorkspaceEffects::default(), fatal_recording_failure: Cell::new(false), log_bytes: 0, log_entries: Vec::new(), secret_values: Vec::new(), resolved_secret_refs: Vec::new(), mock_effects: Some(MockEffects { plans: vec![MockEffectPlan { operation: "log-write".to_string(), request_json: r#"{"level":"error","message":" "}"# .to_string(), response: String::new(), }], trace: Vec::new(), }), }; LogHost::write( &mut state, "error".to_string(), "authorization: secret".to_string(), ) .unwrap(); assert_eq!(state.log_entries, ["error: "]); state.log_bytes = LOG_BYTES_MAX; assert!(LogHost::write(&mut state, "error".to_string(), "x".to_string()).is_err()); } #[test] fn net_scope_rejects_unscoped_destination_before_io() { let mut state = PluginHostState { composition: None, memory_bytes: 0, table_elements: 0, sealed_handles: 0, monotonic_now: 0, ceilings: PluginCeilings::default(), grants: NET_SCOPE_GRANT, effects_enabled: true, lifecycle_deadline: None, lifecycle_allocation_bytes: 0, plugin_id: String::new(), net_scopes: Vec::new(), secret_grants: Vec::new(), oauth_authority: None, workspace_effects: WorkspaceEffects::default(), fatal_recording_failure: Cell::new(false), log_bytes: 0, log_entries: Vec::new(), secret_values: Vec::new(), resolved_secret_refs: Vec::new(), mock_effects: None, }; let error = NetScopeHost::request( &mut state, self::bindings::smith::plugin::net_scope::HttpRequest { destination: "https://example.test".to_string(), method: "POST".to_string(), headers: Vec::new(), body: Vec::new(), options: self::bindings::smith::plugin::net_scope::RequestOptions { timeout_ms: 1, response_bytes_max: 1, }, }, ) .unwrap_err(); assert!(error.contains("explicitly granted origins")); } #[test] fn codec_boundary_rejects_text_and_binary_at_named_limits() { let text = "x".repeat(CODEC_TEXT_BYTES_MAX + 1); assert!( bound_codec_text("provider request", &text, CODEC_TEXT_BYTES_MAX) .unwrap_err() .to_string() .contains("provider request exceeds") ); let bytes = vec![0; CODEC_BINARY_BYTES_MAX + 1]; assert!( bound_codec_bytes("provider response chunk", &bytes, CODEC_BINARY_BYTES_MAX) .unwrap_err() .to_string() .contains("provider response chunk exceeds") ); } #[test] fn limiter_admits_initial_allocation_and_rejects_growth() { let mut ceilings = PluginCeilings::default(); assert!( wasmtime::ResourceLimiter::memory_growing(&mut ceilings, 0, 1, None) .expect("limiter result") ); assert!( !wasmtime::ResourceLimiter::memory_growing(&mut ceilings, 1, 2, None) .expect("limiter result") ); assert!( wasmtime::ResourceLimiter::table_growing(&mut ceilings, 0, 1, None) .expect("limiter result") ); assert!( !wasmtime::ResourceLimiter::table_growing(&mut ceilings, 1, 2, None) .expect("limiter result") ); } } #[cfg(test)] mod runtime_tests;