//! Coherent provider-round publication (SMH-SPEC-SPEC0001, SMH-SPEC-PLUG0001). use super::{ ProtocolConnectionConfig, ProtocolCredential, plugin_fault, protocol_transport_with_loader, registered_protocol_transport, validate_effective_settings, }; use crate::plugins::Capability; use crate::wasm::PluginRegistry; use crate::wasm::{PluginEngine, PluginGeneration}; use futures::StreamExt; use smith::error::{Result, SmithError}; use smith::provider::StreamFn; use smith::tool::CancelHandle; use std::sync::Arc; use std::sync::mpsc::{self, SyncSender}; const PROVIDER_COMMAND_ITEMS: usize = 1; /// Cold runtime-owned configuration plus bounded route to the provider worker. pub struct ProviderRoundOwner { connection: ProtocolConnectionConfig, selection: Option<[String; 3]>, sender: SyncSender, } enum Command { Publish { stream: StreamFn, reply: SyncSender<()>, }, Request { request: smith::provider::ProviderRequest, cancel: CancelHandle, reply: SyncSender, }, } pub fn provider_round_channel( connection: ProtocolConnectionConfig, selection: Option<[String; 3]>, ) -> (StreamFn, ProviderRoundOwner) { let (sender, receiver) = mpsc::sync_channel(PROVIDER_COMMAND_ITEMS); std::thread::spawn(move || { let mut published: Option = None; for command in receiver { match command { Command::Publish { stream, reply } => { published = Some(stream); let _sent = reply.send(()); } Command::Request { request, cancel, reply, } => { let stream = published.as_ref().map_or_else( || failure(plugin_fault("provider round has no published candidate")), |stream| stream(request, cancel), ); // Stream construction queues every initial intent before // replying. Agent drains those records before polling it. let _sent = reply.send(stream); } } } }); let requests = sender.clone(); let stream: StreamFn = Arc::new(move |request, cancel| { let (reply, prepared) = mpsc::sync_channel(PROVIDER_COMMAND_ITEMS); if requests .send(Command::Request { request, cancel, reply, }) .is_err() { return failure(plugin_fault("provider worker stopped")); } prepared .recv() .unwrap_or_else(|_| failure(plugin_fault("provider worker stopped"))) }); ( stream, ProviderRoundOwner { connection, selection, sender, }, ) } fn failure(error: SmithError) -> smith::provider::ProviderStream { futures::stream::iter(std::iter::once(Err(error))).boxed() } impl ProviderRoundOwner { pub(crate) fn redaction_values( &self, store: &smith_ai::auth::AuthStore, ) -> Result> { match &self.connection.credential { ProtocolCredential::ApiKey(reference) => Ok(vec![reference.resolve(store)?]), ProtocolCredential::Subscription(_) => Ok(Vec::new()), } } pub(crate) fn validate_model(&self, model: &str) -> Result<()> { if self .connection .catalog .models .iter() .any(|candidate| candidate.id == model) && self .selection .as_ref() .is_none_or(|selection| selection[1] == model) { return Ok(()); } Err(plugin_fault("model not authorized by selected connection")) } pub(crate) fn validate_provider(&self, provider: &str) -> Result<()> { if self .selection .as_ref() .map_or(provider == self.connection.connection_id, |selection| { selection[0] == provider }) { return Ok(()); } Err(plugin_fault("provider connection unavailable")) } pub(crate) const fn set_include_usage(&mut self, value: bool) { self.connection.settings.include_usage = value; self.connection.settings.provenance = crate::wasm::bindings::exports::smith::plugin::provider::SettingsProvenance::Explicit; } pub(crate) const fn subscription(&self) -> bool { matches!( self.connection.credential, ProtocolCredential::Subscription(_) ) } pub(crate) fn publish( &self, registry: &mut PluginRegistry, engine: &PluginEngine, ) -> Result<()> { let stream = prepare_transport( self.connection.clone(), self.selection.as_ref(), registry, engine, )?; let (reply, accepted) = mpsc::sync_channel(PROVIDER_COMMAND_ITEMS); self.sender .send(Command::Publish { stream, reply }) .map_err(|_| plugin_fault("provider worker stopped"))?; accepted .recv() .map_err(|_| plugin_fault("provider worker stopped")) } } pub(super) fn prepare_transport( connection: ProtocolConnectionConfig, selection: Option<&[String; 3]>, registry: &mut PluginRegistry, engine: &PluginEngine, ) -> Result { if let Some([provider, model, source]) = selection { return registered_protocol_transport(registry, provider, model, source, connection); } let mut generation = if let Some(artifact) = &connection.artifact { PluginGeneration::load( engine, connection.protocol.manifest()?, artifact, &[Capability::NetScope, Capability::SecretProxy], ) } else if let Some(generation) = registry.protocol_generation(connection.protocol.binding())? { // Fresh scratch instance, exact validated code, no path rediscovery. generation.protocol_loader()() } else { PluginGeneration::load_embedded( engine, connection.protocol.manifest()?, connection.protocol.embedded(), &[Capability::NetScope, Capability::SecretProxy], ) }?; match connection.protocol.binding() { Some(binding) => generation.require_protocol_binding(binding)?, None => generation.require_responses_binding()?, } validate_effective_settings(&mut generation, connection.settings)?; let load = generation.protocol_loader(); let credential_load = match &connection.credential { ProtocolCredential::ApiKey(_) => None, ProtocolCredential::Subscription(credential) => { let generation = registry.bind_credential_source_with_override( credential.provider().consumer(), credential.provider().source(), credential.module_override(), )?; Some(Arc::new(generation.protocol_loader()) as crate::wasm::GenerationLoader) } }; Ok(protocol_transport_with_loader( connection, load, None, credential_load, )) } #[cfg(all(test, target_arch = "x86_64"))] mod tests { //! SMH-SPEC-SPEC0001: bounded round handoff holds owned request data. use super::*; #[test] fn round_handoff_layout_is_exact() { assert_eq!(std::mem::size_of::(), 168); assert_eq!(std::mem::size_of::(), 16); } }