#![allow(clippy::items_after_test_module)]
use std::collections::{BTreeMap, BTreeSet};
use std::sync::{Arc, RwLock};
use serde::{Deserialize, Serialize};
use crate::{
ProgressSender, ToolCall, ToolContext, ToolContract, ToolManifest, ToolProvider, ToolResult,
};
const PLUGIN_SOURCE_ID: &str = "plugins";
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ToolSourceHandle {
id: String,
}
impl ToolSourceHandle {
pub(crate) fn new(id: impl Into<String>) -> Self {
Self { id: id.into() }
}
pub(crate) fn as_str(&self) -> &str {
&self.id
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ToolStateEntry {
manifest: ToolManifest,
source_id: String,
}
impl ToolStateEntry {
pub fn manifest(&self) -> &ToolManifest {
&self.manifest
}
pub fn manifest_mut(&mut self) -> &mut ToolManifest {
&mut self.manifest
}
}
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct ToolState {
generation: u64,
tools: BTreeMap<String, ToolStateEntry>,
}
impl ToolState {
pub(crate) fn new(generation: u64, tools: BTreeMap<String, ToolStateEntry>) -> Self {
Self { generation, tools }
}
pub fn generation(&self) -> u64 {
self.generation
}
pub fn with_generation(mut self, generation: u64) -> Self {
self.generation = generation;
self
}
pub fn tool_manifests(&self) -> Vec<ToolManifest> {
self.tools
.values()
.map(|entry| entry.manifest.clone())
.collect()
}
pub fn get(&self, name: &str) -> Option<&ToolStateEntry> {
self.tools.get(name)
}
pub fn manifest_mut(&mut self, name: &str) -> Option<&mut ToolManifest> {
self.tools.get_mut(name).map(|entry| &mut entry.manifest)
}
pub fn contains(&self, name: &str) -> bool {
self.tools.contains_key(name)
}
pub fn is_empty(&self) -> bool {
self.tools.is_empty()
}
pub fn len(&self) -> usize {
self.tools.len()
}
pub fn iter(&self) -> impl Iterator<Item = (&str, &ToolStateEntry)> {
self.tools
.iter()
.map(|(name, entry)| (name.as_str(), entry))
}
pub fn set_availability(
&mut self,
name: &str,
availability: Option<crate::ToolAvailability>,
) -> Result<(), ReconfigureError> {
let Some(entry) = self.tools.get_mut(name) else {
return Err(ReconfigureError::Validation(format!(
"unknown tool `{name}`"
)));
};
entry.manifest.availability_override = availability;
Ok(())
}
pub fn retain(&mut self, mut keep: impl FnMut(&str, &ToolStateEntry) -> bool) {
self.tools.retain(|name, entry| keep(name, entry));
}
pub fn remove(&mut self, name: &str) -> Option<ToolStateEntry> {
self.tools.remove(name)
}
pub(crate) fn entries(&self) -> &BTreeMap<String, ToolStateEntry> {
&self.tools
}
pub(crate) fn into_entries(self) -> BTreeMap<String, ToolStateEntry> {
self.tools
}
}
#[async_trait::async_trait]
pub(crate) trait ToolSourceExecutor: Send + Sync + 'static {
fn id(&self) -> &str;
fn advertised_tools(&self) -> Vec<ToolManifest>;
fn resolve_manifest(&self, name: &str) -> Option<ToolManifest> {
self.advertised_tools()
.into_iter()
.find(|manifest| manifest.name == name)
}
fn resolve_contract(&self, name: &str) -> Option<Arc<ToolContract>>;
async fn execute(
&self,
tool: &str,
args: &serde_json::Value,
context: &ToolContext,
progress: Option<&ProgressSender>,
) -> ToolResult;
}
struct ToolProviderSource {
id: String,
provider: Arc<dyn ToolProvider>,
}
impl ToolProviderSource {
fn new(id: impl Into<String>, provider: Arc<dyn ToolProvider>) -> Self {
Self {
id: id.into(),
provider,
}
}
}
#[async_trait::async_trait]
impl ToolSourceExecutor for ToolProviderSource {
fn id(&self) -> &str {
&self.id
}
fn advertised_tools(&self) -> Vec<ToolManifest> {
self.provider.tool_manifests()
}
fn resolve_manifest(&self, name: &str) -> Option<ToolManifest> {
self.provider.resolve_manifest(name)
}
fn resolve_contract(&self, name: &str) -> Option<Arc<ToolContract>> {
self.provider.resolve_contract(name)
}
async fn execute(
&self,
tool: &str,
args: &serde_json::Value,
context: &ToolContext,
progress: Option<&ProgressSender>,
) -> ToolResult {
self.provider
.execute(ToolCall {
name: tool,
args,
context,
progress,
})
.await
}
}
#[derive(Clone)]
struct ToolRegistryState {
generation: u64,
tools: BTreeMap<String, ToolStateEntry>,
next_live_source_id: u64,
}
#[derive(Debug, thiserror::Error)]
pub enum ReconfigureError {
#[error("validation error: {0}")]
Validation(String),
#[error("unknown tool source: {0}")]
UnknownSource(String),
#[error("generation mismatch: expected {expected}, actual {actual}")]
GenerationMismatch { expected: u64, actual: u64 },
}
#[derive(Clone)]
pub struct ToolRegistry {
sources: Arc<RwLock<BTreeMap<String, Arc<dyn ToolSourceExecutor>>>>,
state: Arc<RwLock<ToolRegistryState>>,
}
impl ToolRegistry {
pub fn from_tool_provider(provider: Arc<dyn ToolProvider>) -> Result<Self, ReconfigureError> {
let registry = Self::empty();
registry.upsert_source(Arc::new(ToolProviderSource::new(
PLUGIN_SOURCE_ID,
provider,
)))?;
Ok(registry)
}
pub(crate) fn empty() -> Self {
Self {
sources: Arc::new(RwLock::new(BTreeMap::new())),
state: Arc::new(RwLock::new(ToolRegistryState {
generation: 0,
tools: BTreeMap::new(),
next_live_source_id: 0,
})),
}
}
pub fn generation(&self) -> u64 {
self.state
.read()
.expect("tool registry state lock poisoned")
.generation
}
pub fn export_state(&self) -> ToolState {
let state = self
.state
.read()
.expect("tool registry state lock poisoned");
ToolState::new(state.generation, state.tools.clone())
}
pub fn apply_state(&self, next: ToolState) -> Result<u64, ReconfigureError> {
let current_generation = self.generation();
if next.generation != current_generation {
return Err(ReconfigureError::GenerationMismatch {
expected: next.generation,
actual: current_generation,
});
}
{
let sources = self.sources.read().expect("tool source lock poisoned");
for entry in next.entries().values() {
let Some(source) = sources.get(&entry.source_id) else {
return Err(ReconfigureError::UnknownSource(entry.source_id.clone()));
};
if source.resolve_manifest(&entry.manifest.name).is_none() {
return Err(ReconfigureError::Validation(format!(
"tool source `{}` does not resolve tool `{}`",
entry.source_id, entry.manifest.name
)));
}
}
}
let mut state = self
.state
.write()
.expect("tool registry state lock poisoned");
if state.generation != next.generation {
return Err(ReconfigureError::GenerationMismatch {
expected: next.generation,
actual: state.generation,
});
}
state.tools = next.into_entries();
state.generation += 1;
Ok(state.generation)
}
pub fn add_tool_provider(
&self,
provider: Arc<dyn ToolProvider>,
) -> Result<ToolSourceHandle, ReconfigureError> {
let source_id = {
let mut state = self
.state
.write()
.expect("tool registry state lock poisoned");
state.next_live_source_id += 1;
format!("live:{}", state.next_live_source_id)
};
self.upsert_source(Arc::new(ToolProviderSource::new(
source_id.clone(),
provider,
)))?;
Ok(ToolSourceHandle::new(source_id))
}
pub(crate) fn upsert_source(
&self,
source: Arc<dyn ToolSourceExecutor>,
) -> Result<u64, ReconfigureError> {
let source_id = source.id().to_string();
let advertised_tools = source.advertised_tools();
validate_unique_manifests(&advertised_tools)?;
let mut state = self
.state
.write()
.expect("tool registry state lock poisoned");
let previous_overrides = state
.tools
.iter()
.map(|(name, entry)| (name.clone(), entry.manifest.availability_override))
.collect::<BTreeMap<_, _>>();
let same_source_names = state
.tools
.iter()
.filter_map(|(name, entry)| (entry.source_id == source_id).then_some(name.clone()))
.collect::<BTreeSet<_>>();
for manifest in &advertised_tools {
if let Some(existing) = state.tools.get(&manifest.name)
&& existing.source_id != source_id
{
return Err(ReconfigureError::Validation(format!(
"duplicate tool name `{}` from source `{}` conflicts with source `{}`",
manifest.name, source_id, existing.source_id
)));
}
}
state.tools.retain(|name, entry| {
entry.source_id != source_id || !same_source_names.contains(name)
});
for mut manifest in advertised_tools {
let name = manifest.name.clone();
manifest.availability_override = previous_overrides
.get(&name)
.copied()
.flatten()
.or(manifest.availability_override);
state.tools.insert(
name,
ToolStateEntry {
manifest,
source_id: source_id.clone(),
},
);
}
self.sources
.write()
.expect("tool source lock poisoned")
.insert(source_id, source);
state.generation += 1;
Ok(state.generation)
}
pub fn remove_source(&self, handle: &ToolSourceHandle) -> Result<u64, ReconfigureError> {
self.remove_source_id(handle.as_str())
}
pub(crate) fn remove_source_id(&self, source_id: &str) -> Result<u64, ReconfigureError> {
{
let mut sources = self.sources.write().expect("tool source lock poisoned");
if sources.remove(source_id).is_none() {
return Err(ReconfigureError::UnknownSource(source_id.to_string()));
}
}
let mut state = self
.state
.write()
.expect("tool registry state lock poisoned");
state.tools.retain(|_, entry| entry.source_id != source_id);
state.generation += 1;
Ok(state.generation)
}
pub(crate) fn fork_with_state(&self, snapshot: ToolState) -> Result<Self, ReconfigureError> {
let sources = self
.sources
.read()
.expect("tool source lock poisoned")
.iter()
.map(|(k, v)| (k.clone(), Arc::clone(v)))
.collect();
let generation = snapshot.generation.max(1);
Ok(Self {
sources: Arc::new(RwLock::new(sources)),
state: Arc::new(RwLock::new(ToolRegistryState {
generation,
tools: snapshot.into_entries(),
next_live_source_id: 0,
})),
})
}
}
#[async_trait::async_trait]
impl ToolProvider for ToolRegistry {
fn tool_manifests(&self) -> Vec<ToolManifest> {
let state = self
.state
.read()
.expect("tool registry state lock poisoned");
state
.tools
.values()
.map(|entry| entry.manifest.clone())
.collect()
}
fn resolve_manifest(&self, name: &str) -> Option<ToolManifest> {
if let Some(manifest) = {
let state = self
.state
.read()
.expect("tool registry state lock poisoned");
state.tools.get(name).map(|entry| entry.manifest.clone())
} {
return Some(manifest);
}
let sources = self
.sources
.read()
.expect("tool source lock poisoned")
.iter()
.map(|(source_id, source)| (source_id.clone(), Arc::clone(source)))
.collect::<Vec<_>>();
for (source_id, source) in sources {
let Some(mut manifest) = source.resolve_manifest(name) else {
continue;
};
let previous_override = {
let state = self
.state
.read()
.expect("tool registry state lock poisoned");
state
.tools
.get(&manifest.name)
.and_then(|entry| entry.manifest.availability_override)
};
manifest.availability_override = previous_override.or(manifest.availability_override);
let mut state = self
.state
.write()
.expect("tool registry state lock poisoned");
if let Some(existing) = state.tools.get(&manifest.name) {
return (existing.source_id == source_id).then(|| existing.manifest.clone());
}
state.tools.insert(
manifest.name.clone(),
ToolStateEntry {
manifest: manifest.clone(),
source_id,
},
);
state.generation += 1;
return Some(manifest);
}
None
}
fn resolve_contract(&self, name: &str) -> Option<Arc<ToolContract>> {
let source_id = self.resolve_manifest(name).and_then(|_| {
let state = self
.state
.read()
.expect("tool registry state lock poisoned");
state.tools.get(name).map(|entry| entry.source_id.clone())
})?;
self.sources
.read()
.expect("tool source lock poisoned")
.get(&source_id)?
.resolve_contract(name)
}
async fn execute(&self, call: ToolCall<'_>) -> ToolResult {
let name = call.name;
let source_id = self.resolve_manifest(name).and_then(|_| {
let state = self
.state
.read()
.expect("tool registry state lock poisoned");
state.tools.get(name).map(|entry| entry.source_id.clone())
});
let Some(source_id) = source_id else {
return ToolResult::err_fmt(format_args!("Unknown tool: {name}"));
};
let source = {
self.sources
.read()
.expect("tool source lock poisoned")
.get(&source_id)
.cloned()
};
let Some(source) = source else {
return ToolResult::err_fmt(format_args!("Tool source missing for tool `{name}`"));
};
source
.execute(name, call.args, call.context, call.progress)
.await
}
}
fn validate_unique_manifests(manifests: &[ToolManifest]) -> Result<(), ReconfigureError> {
let mut names = BTreeSet::new();
for manifest in manifests {
if manifest.name.trim().is_empty() {
return Err(ReconfigureError::Validation(
"tool name cannot be empty".to_string(),
));
}
if !names.insert(manifest.name.clone()) {
return Err(ReconfigureError::Validation(format!(
"duplicate tool name `{}` in source",
manifest.name
)));
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ToolDefinition;
use serde_json::json;
use std::sync::atomic::{AtomicUsize, Ordering};
struct MockTool;
struct MixedEnabledTool;
struct ExternalMockSource;
struct ExactResolvingSource {
manifest_resolutions: Arc<AtomicUsize>,
contract_resolutions: Arc<AtomicUsize>,
executions: Arc<AtomicUsize>,
}
fn test_tool(
name: &str,
description: &str,
availability: crate::ToolAvailabilityConfig,
) -> ToolDefinition {
ToolDefinition::raw(
name,
description,
ToolDefinition::default_input_schema(),
json!({ "type": "string" }),
)
.with_availability(availability)
}
fn manifests(definitions: Vec<ToolDefinition>) -> Vec<ToolManifest> {
definitions
.into_iter()
.map(|tool| tool.manifest())
.collect()
}
fn contract_from(definitions: Vec<ToolDefinition>, name: &str) -> Option<Arc<ToolContract>> {
definitions
.into_iter()
.find(|tool| tool.name == name)
.map(|tool| Arc::new(tool.contract()))
}
#[async_trait::async_trait]
impl ToolProvider for MockTool {
fn tool_manifests(&self) -> Vec<ToolManifest> {
manifests(vec![test_tool(
"mock_tool",
"mock",
crate::ToolAvailabilityConfig::callable(),
)])
}
fn resolve_contract(&self, name: &str) -> Option<Arc<ToolContract>> {
contract_from(
vec![test_tool(
"mock_tool",
"mock",
crate::ToolAvailabilityConfig::callable(),
)],
name,
)
}
async fn execute(&self, _call: ToolCall<'_>) -> ToolResult {
ToolResult::ok(serde_json::json!("ok"))
}
}
#[async_trait::async_trait]
impl ToolProvider for MixedEnabledTool {
fn tool_manifests(&self) -> Vec<ToolManifest> {
manifests(vec![
test_tool(
"enabled_tool",
"enabled",
crate::ToolAvailabilityConfig::callable(),
),
test_tool(
"disabled_tool",
"disabled",
crate::ToolAvailabilityConfig::off(),
),
])
}
fn resolve_contract(&self, name: &str) -> Option<Arc<ToolContract>> {
contract_from(
vec![
test_tool(
"enabled_tool",
"enabled",
crate::ToolAvailabilityConfig::callable(),
),
test_tool(
"disabled_tool",
"disabled",
crate::ToolAvailabilityConfig::off(),
),
],
name,
)
}
async fn execute(&self, _call: ToolCall<'_>) -> ToolResult {
ToolResult::ok(serde_json::json!("ok"))
}
}
#[async_trait::async_trait]
impl ToolSourceExecutor for ExternalMockSource {
fn id(&self) -> &str {
"external"
}
fn advertised_tools(&self) -> Vec<ToolManifest> {
manifests(vec![ToolDefinition::raw(
"mcp__demo__search",
"search",
json!({
"type": "object",
"properties": {
"query": { "type": "string" }
},
"required": ["query"],
"additionalProperties": false
}),
json!({ "type": "object", "additionalProperties": true }),
)])
}
fn resolve_contract(&self, name: &str) -> Option<Arc<ToolContract>> {
contract_from(
vec![ToolDefinition::raw(
"mcp__demo__search",
"search",
json!({
"type": "object",
"properties": {
"query": { "type": "string" }
},
"required": ["query"],
"additionalProperties": false
}),
json!({ "type": "object", "additionalProperties": true }),
)],
name,
)
}
async fn execute(
&self,
tool: &str,
args: &serde_json::Value,
_context: &ToolContext,
_progress: Option<&ProgressSender>,
) -> ToolResult {
ToolResult::ok(json!({
"tool": tool,
"args": args
}))
}
}
#[async_trait::async_trait]
impl ToolSourceExecutor for ExactResolvingSource {
fn id(&self) -> &str {
"exact"
}
fn advertised_tools(&self) -> Vec<ToolManifest> {
Vec::new()
}
fn resolve_manifest(&self, name: &str) -> Option<ToolManifest> {
self.manifest_resolutions.fetch_add(1, Ordering::SeqCst);
(name == "host_only").then(|| {
test_tool(
"host_only",
"host-only",
crate::ToolAvailabilityConfig::callable(),
)
.manifest()
})
}
fn resolve_contract(&self, name: &str) -> Option<Arc<ToolContract>> {
self.contract_resolutions.fetch_add(1, Ordering::SeqCst);
contract_from(
vec![test_tool(
"host_only",
"host-only",
crate::ToolAvailabilityConfig::callable(),
)],
name,
)
}
async fn execute(
&self,
tool: &str,
_args: &serde_json::Value,
_context: &ToolContext,
_progress: Option<&ProgressSender>,
) -> ToolResult {
self.executions.fetch_add(1, Ordering::SeqCst);
ToolResult::ok(json!(tool))
}
}
#[test]
fn registry_preserves_initial_availability_state() {
let registry =
ToolRegistry::from_tool_provider(Arc::new(MixedEnabledTool)).expect("registry");
let snapshot = registry.export_state();
assert_eq!(
snapshot
.get("enabled_tool")
.unwrap()
.manifest()
.effective_availability(&crate::ExecutionMode::standard()),
crate::ToolAvailability::Callable
);
assert_eq!(
snapshot
.get("disabled_tool")
.unwrap()
.manifest()
.effective_availability(&crate::ExecutionMode::standard()),
crate::ToolAvailability::Off
);
}
#[test]
fn apply_state_rejects_tools_not_advertised_by_source() {
let registry = ToolRegistry::from_tool_provider(Arc::new(MockTool)).expect("registry");
let mut snapshot = registry.export_state();
snapshot.tools.insert(
"missing".to_string(),
ToolStateEntry {
manifest: test_tool(
"missing",
"missing",
crate::ToolAvailabilityConfig::callable(),
)
.manifest(),
source_id: PLUGIN_SOURCE_ID.to_string(),
},
);
assert!(matches!(
registry.apply_state(snapshot),
Err(ReconfigureError::Validation(_))
));
}
#[test]
fn advertised_manifest_resolves_without_exact_host_lookup() {
let manifest_resolutions = Arc::new(AtomicUsize::new(0));
let registry = ToolRegistry::from_tool_provider(Arc::new(MockTool)).expect("registry");
registry
.upsert_source(Arc::new(ExactResolvingSource {
manifest_resolutions: Arc::clone(&manifest_resolutions),
contract_resolutions: Arc::new(AtomicUsize::new(0)),
executions: Arc::new(AtomicUsize::new(0)),
}))
.expect("source registered");
assert_eq!(
registry
.resolve_manifest("mock_tool")
.map(|manifest| manifest.name),
Some("mock_tool".to_string())
);
assert_eq!(manifest_resolutions.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn unknown_manifest_exact_resolves_and_routes_to_owner() {
let manifest_resolutions = Arc::new(AtomicUsize::new(0));
let contract_resolutions = Arc::new(AtomicUsize::new(0));
let executions = Arc::new(AtomicUsize::new(0));
let registry = ToolRegistry::from_tool_provider(Arc::new(MockTool)).expect("registry");
registry
.upsert_source(Arc::new(ExactResolvingSource {
manifest_resolutions: Arc::clone(&manifest_resolutions),
contract_resolutions: Arc::clone(&contract_resolutions),
executions: Arc::clone(&executions),
}))
.expect("source registered");
assert_eq!(
registry
.resolve_manifest("host_only")
.map(|manifest| manifest.name),
Some("host_only".to_string())
);
assert_eq!(manifest_resolutions.load(Ordering::SeqCst), 1);
let contract = registry.resolve_contract("host_only");
assert!(contract.is_some());
assert_eq!(manifest_resolutions.load(Ordering::SeqCst), 1);
assert_eq!(contract_resolutions.load(Ordering::SeqCst), 1);
let context = crate::ToolContext::new(
"registry-test".to_string(),
Arc::new(crate::testing::MockSessionManager::default()),
crate::TurnContext::default(),
Arc::new(crate::InMemoryAttachmentStore::new()),
None,
);
let args = json!({});
let result = registry
.execute(crate::ToolCall {
name: "host_only",
args: &args,
context: &context,
progress: None,
})
.await;
assert!(result.is_success());
assert_eq!(result.value_for_projection(), json!("host_only"));
assert_eq!(executions.load(Ordering::SeqCst), 1);
}
#[test]
fn unknown_manifest_without_host_resolver_is_unavailable() {
let registry = ToolRegistry::from_tool_provider(Arc::new(MockTool)).expect("registry");
assert!(registry.resolve_manifest("missing").is_none());
assert!(registry.resolve_contract("missing").is_none());
}
#[tokio::test]
async fn upsert_source_registers_and_executes_external_tools() {
let registry = ToolRegistry::from_tool_provider(Arc::new(MockTool)).expect("registry");
registry
.upsert_source(Arc::new(ExternalMockSource))
.expect("source registered");
let defs = registry.tool_manifests();
assert!(defs.iter().any(|def| def.name == "mcp__demo__search"));
let context = crate::ToolContext::new(
"registry-test".to_string(),
Arc::new(crate::testing::MockSessionManager::default()),
crate::TurnContext::default(),
Arc::new(crate::InMemoryAttachmentStore::new()),
None,
);
let args = json!({ "query": "hello" });
let result = registry
.execute(crate::ToolCall {
name: "mcp__demo__search",
args: &args,
context: &context,
progress: None,
})
.await;
assert!(result.is_success());
assert_eq!(
result.value_for_projection()["tool"],
json!("mcp__demo__search")
);
assert_eq!(
result.value_for_projection()["args"]["query"],
json!("hello")
);
}
#[test]
fn upsert_source_preserves_availability_override_on_refresh() {
let registry = ToolRegistry::from_tool_provider(Arc::new(MockTool)).expect("registry");
registry
.upsert_source(Arc::new(ExternalMockSource))
.expect("source registered");
let mut snapshot = registry.export_state();
snapshot
.set_availability("mcp__demo__search", Some(crate::ToolAvailability::Off))
.unwrap();
registry.apply_state(snapshot).unwrap();
registry
.upsert_source(Arc::new(ExternalMockSource))
.expect("source refreshed");
let snapshot = registry.export_state();
assert_eq!(
snapshot
.get("mcp__demo__search")
.unwrap()
.manifest()
.effective_availability(&crate::ExecutionMode::standard()),
crate::ToolAvailability::Off
);
}
#[test]
fn remove_source_removes_all_source_tools() {
let registry = ToolRegistry::from_tool_provider(Arc::new(MockTool)).expect("registry");
registry
.upsert_source(Arc::new(ExternalMockSource))
.expect("source registered");
registry
.remove_source_id("external")
.expect("source removed");
let defs = registry.tool_manifests();
assert!(!defs.iter().any(|def| def.name == "mcp__demo__search"));
}
#[test]
fn project_tool_catalog_keeps_searchable_tools_with_surface_metadata() {
fn dummy_tool(name: &str) -> crate::ToolDefinition {
crate::ToolDefinition::raw(
name,
format!("desc for {name}"),
crate::ToolDefinition::default_input_schema(),
serde_json::json!({}),
)
}
let catalog = project_tool_catalog([
crate::ToolSurfaceEntry {
manifest: dummy_tool("read_file").manifest(),
availability: crate::ToolAvailability::Showcased,
},
crate::ToolSurfaceEntry {
manifest: dummy_tool("search_tools").manifest(),
availability: crate::ToolAvailability::Callable,
},
]);
assert_eq!(catalog.len(), 2);
assert_eq!(catalog[0]["name"], serde_json::json!("read_file"));
assert!(catalog[0].get("signature").is_none());
assert_eq!(catalog[0]["showcased"], serde_json::json!(true));
assert_eq!(catalog[1]["callable"], serde_json::json!(true));
}
#[test]
fn project_tool_catalog_preserves_dynamic_output_contracts() {
fn dummy_tool(name: &str) -> crate::ToolDefinition {
crate::ToolDefinition::raw(
name,
format!("desc for {name}"),
crate::ToolDefinition::default_input_schema(),
serde_json::json!({}),
)
}
let catalog = project_tool_catalog([crate::ToolSurfaceEntry {
manifest: dummy_tool("llm_query")
.with_output_from_input_schema(
"output",
Some(serde_json::json!({ "type": "string" })),
)
.manifest(),
availability: crate::ToolAvailability::Searchable,
}]);
assert!(catalog[0].get("output_contract").is_none());
}
}
pub(crate) fn project_tool_catalog<I>(entries: I) -> Vec<serde_json::Value>
where
I: IntoIterator<Item = crate::ToolSurfaceEntry>,
{
entries
.into_iter()
.filter(|entry| entry.availability.is_searchable())
.map(|entry| {
let manifest = entry.manifest;
let availability = entry.availability;
let projected = serde_json::json!({
"name": manifest.name,
"namespace": manifest.discovery.namespace,
"description": manifest.description,
"aliases": manifest.discovery.aliases,
"availability": availability,
"callable": availability.is_callable(),
"showcased": availability.is_showcased(),
"searchable": availability.is_searchable(),
"activation": manifest.activation,
});
projected
})
.collect()
}