use std::{collections::BTreeMap, fmt, sync::Arc};
use stateknot_core::{CapabilityIdentity, ErasedTool, Model, ModelDescriptor, ToolDescriptor};
use thiserror::Error;
struct ModelProviderBinding {
descriptor: ModelDescriptor,
provider: Arc<dyn Model>,
}
#[derive(Default)]
pub struct ModelProviderRegistryBuilder {
bindings: BTreeMap<CapabilityIdentity, ModelProviderBinding>,
}
impl ModelProviderRegistryBuilder {
pub const MAX_BINDINGS: usize = 4096;
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn register(&mut self, provider: Arc<dyn Model>) -> Result<(), ModelProviderRegistryError> {
if self.bindings.len() == Self::MAX_BINDINGS {
return Err(ModelProviderRegistryError::TooManyBindings);
}
let descriptor = provider.descriptor().clone();
let identity = descriptor.metadata().identity().clone();
if self.bindings.contains_key(&identity) {
return Err(ModelProviderRegistryError::DuplicateIdentity {
identity: Box::new(identity),
});
}
self.bindings.insert(
identity,
ModelProviderBinding {
descriptor,
provider,
},
);
Ok(())
}
#[must_use]
pub fn build(self) -> ModelProviderRegistry {
ModelProviderRegistry {
bindings: Arc::new(self.bindings),
}
}
}
impl fmt::Debug for ModelProviderRegistryBuilder {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ModelProviderRegistryBuilder")
.field("bindings", &self.bindings.len())
.finish_non_exhaustive()
}
}
#[derive(Clone)]
pub struct ModelProviderRegistry {
bindings: Arc<BTreeMap<CapabilityIdentity, ModelProviderBinding>>,
}
impl ModelProviderRegistry {
pub fn resolve(
&self,
descriptor: &ModelDescriptor,
) -> Result<Arc<dyn Model>, ModelProviderRegistryError> {
let identity = descriptor.metadata().identity();
let binding = self.bindings.get(identity).ok_or_else(|| {
ModelProviderRegistryError::MissingBinding {
identity: Box::new(identity.clone()),
}
})?;
if &binding.descriptor != descriptor || binding.provider.descriptor() != descriptor {
return Err(ModelProviderRegistryError::DescriptorMismatch {
identity: Box::new(identity.clone()),
});
}
Ok(Arc::clone(&binding.provider))
}
#[must_use]
pub fn len(&self) -> usize {
self.bindings.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.bindings.is_empty()
}
}
impl fmt::Debug for ModelProviderRegistry {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ModelProviderRegistry")
.field("bindings", &self.bindings.len())
.finish_non_exhaustive()
}
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[non_exhaustive]
pub enum ModelProviderRegistryError {
#[error("model provider registry contains too many bindings")]
TooManyBindings,
#[error("model provider identity was registered more than once")]
DuplicateIdentity {
identity: Box<CapabilityIdentity>,
},
#[error("durable model descriptor has no installed provider binding")]
MissingBinding {
identity: Box<CapabilityIdentity>,
},
#[error("installed model provider descriptor differs from durable snapshot")]
DescriptorMismatch {
identity: Box<CapabilityIdentity>,
},
}
struct ToolProviderBinding {
descriptor: ToolDescriptor,
provider: Arc<dyn ErasedTool>,
}
#[derive(Default)]
pub struct ToolProviderRegistryBuilder {
bindings: BTreeMap<CapabilityIdentity, ToolProviderBinding>,
}
impl ToolProviderRegistryBuilder {
pub const MAX_BINDINGS: usize = 16_384;
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn register(
&mut self,
provider: Arc<dyn ErasedTool>,
) -> Result<(), ToolProviderRegistryError> {
if self.bindings.len() == Self::MAX_BINDINGS {
return Err(ToolProviderRegistryError::TooManyBindings);
}
let descriptor = provider.descriptor().clone();
let identity = descriptor.metadata().identity().clone();
if provider.supports_reconciliation() && !descriptor.semantics().supports_status_query() {
return Err(
ToolProviderRegistryError::ReconciliationCapabilityMismatch {
identity: Box::new(identity),
},
);
}
if self.bindings.contains_key(&identity) {
return Err(ToolProviderRegistryError::DuplicateIdentity {
identity: Box::new(identity),
});
}
self.bindings.insert(
identity,
ToolProviderBinding {
descriptor,
provider,
},
);
Ok(())
}
#[must_use]
pub fn build(self) -> ToolProviderRegistry {
ToolProviderRegistry {
bindings: Arc::new(self.bindings),
}
}
}
impl fmt::Debug for ToolProviderRegistryBuilder {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ToolProviderRegistryBuilder")
.field("bindings", &self.bindings.len())
.finish_non_exhaustive()
}
}
#[derive(Clone)]
pub struct ToolProviderRegistry {
bindings: Arc<BTreeMap<CapabilityIdentity, ToolProviderBinding>>,
}
impl ToolProviderRegistry {
pub fn resolve(
&self,
descriptor: &ToolDescriptor,
) -> Result<Arc<dyn ErasedTool>, ToolProviderRegistryError> {
let identity = descriptor.metadata().identity();
let binding = self.bindings.get(identity).ok_or_else(|| {
ToolProviderRegistryError::MissingBinding {
identity: Box::new(identity.clone()),
}
})?;
if &binding.descriptor != descriptor || binding.provider.descriptor() != descriptor {
return Err(ToolProviderRegistryError::DescriptorMismatch {
identity: Box::new(identity.clone()),
});
}
Ok(Arc::clone(&binding.provider))
}
#[must_use]
pub fn len(&self) -> usize {
self.bindings.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.bindings.is_empty()
}
}
impl fmt::Debug for ToolProviderRegistry {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ToolProviderRegistry")
.field("bindings", &self.bindings.len())
.finish_non_exhaustive()
}
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[non_exhaustive]
pub enum ToolProviderRegistryError {
#[error("tool provider registry contains too many bindings")]
TooManyBindings,
#[error("tool provider identity was registered more than once")]
DuplicateIdentity {
identity: Box<CapabilityIdentity>,
},
#[error("durable tool descriptor has no installed provider binding")]
MissingBinding {
identity: Box<CapabilityIdentity>,
},
#[error("installed tool provider descriptor differs from durable snapshot")]
DescriptorMismatch {
identity: Box<CapabilityIdentity>,
},
#[error("tool reconciliation capability differs from its descriptor declaration")]
ReconciliationCapabilityMismatch {
identity: Box<CapabilityIdentity>,
},
}
#[cfg(test)]
mod tests {
use stateknot_core::{
BoxFuture, BoxStream, ModelContext, ModelError, ModelEvent, ModelRequest, ModelResponse,
ToolContext, ToolError, ToolInput, ToolResult,
};
use super::*;
struct TestModel {
descriptor: ModelDescriptor,
}
impl Model for TestModel {
fn descriptor(&self) -> &ModelDescriptor {
&self.descriptor
}
fn invoke(
&self,
_: ModelContext,
_: ModelRequest,
) -> BoxFuture<'_, Result<ModelResponse, ModelError>> {
unimplemented!("provider registry tests never dispatch")
}
fn stream(
&self,
_: ModelContext,
_: ModelRequest,
) -> BoxStream<'_, Result<ModelEvent, ModelError>> {
unimplemented!("provider registry tests never dispatch")
}
}
struct TestTool {
descriptor: ToolDescriptor,
}
impl ErasedTool for TestTool {
fn descriptor(&self) -> &ToolDescriptor {
&self.descriptor
}
fn supports_reconciliation(&self) -> bool {
true
}
fn call(
&self,
_: ToolContext,
_: ToolInput,
) -> BoxFuture<'_, Result<ToolResult, ToolError>> {
unimplemented!("provider registry tests never dispatch")
}
}
fn model_descriptor(name: &str) -> ModelDescriptor {
let fixture: serde_json::Value = serde_json::from_str(include_str!(
"../../stateknot-core/tests/fixtures/core-model-descriptor-v1.json"
))
.unwrap();
let mut descriptor = fixture["descriptors"]["valid"][0].clone();
descriptor["metadata"]["identity"]["capability"]["name"] =
serde_json::Value::String(name.to_owned());
serde_json::from_value(descriptor).unwrap()
}
fn tool_descriptor(name: &str) -> ToolDescriptor {
let fixture: serde_json::Value = serde_json::from_str(include_str!(
"../../stateknot-core/tests/fixtures/core-tool-v1.json"
))
.unwrap();
let mut descriptor = fixture["descriptors"]["valid"][0].clone();
descriptor["metadata"]["identity"]["capability"]["name"] =
serde_json::Value::String(name.to_owned());
serde_json::from_value(descriptor).unwrap()
}
fn tool_descriptor_without_status_query(name: &str) -> ToolDescriptor {
let mut descriptor = serde_json::to_value(tool_descriptor(name)).unwrap();
descriptor["semantics"]["status_query"] = serde_json::Value::Bool(false);
serde_json::from_value(descriptor).unwrap()
}
#[test]
fn model_registry_rejects_duplicates_and_descriptor_substitution() {
let primary = model_descriptor("models.primary");
let alternate = model_descriptor("models.alternate");
let mut builder = ModelProviderRegistryBuilder::new();
builder
.register(Arc::new(TestModel {
descriptor: primary.clone(),
}))
.unwrap();
assert!(matches!(
builder.register(Arc::new(TestModel {
descriptor: primary.clone()
})),
Err(ModelProviderRegistryError::DuplicateIdentity { .. })
));
let registry = builder.build();
assert!(registry.resolve(&primary).is_ok());
assert!(matches!(
registry.resolve(&alternate),
Err(ModelProviderRegistryError::MissingBinding { .. })
));
}
#[test]
fn tool_registry_rejects_duplicates_and_missing_exact_versions() {
let primary = tool_descriptor("payments.capture");
let alternate = tool_descriptor("payments.refund");
let mut builder = ToolProviderRegistryBuilder::new();
builder
.register(Arc::new(TestTool {
descriptor: primary.clone(),
}))
.unwrap();
assert!(matches!(
builder.register(Arc::new(TestTool {
descriptor: primary.clone()
})),
Err(ToolProviderRegistryError::DuplicateIdentity { .. })
));
let registry = builder.build();
assert!(registry.resolve(&primary).is_ok());
assert!(matches!(
registry.resolve(&alternate),
Err(ToolProviderRegistryError::MissingBinding { .. })
));
}
#[test]
fn tool_registry_rejects_undeclared_reconciliation_implementations() {
let mut builder = ToolProviderRegistryBuilder::new();
assert!(matches!(
builder.register(Arc::new(TestTool {
descriptor: tool_descriptor_without_status_query("payments.unreconciled"),
})),
Err(ToolProviderRegistryError::ReconciliationCapabilityMismatch { .. })
));
}
}