tools-kit 0.0.2

Portable Local and MCP tool execution with narrow extension traits.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use std::{collections::BTreeMap, sync::Arc};

use crate::{
    ToolError, ToolsetBackend,
    declaration::ToolInfo,
    local::{RegisteredTool, ToolRegistration},
    name::ToolName,
};

pub(crate) mod handler;

#[derive(Debug)]
pub(crate) struct LocalToolset {
    tools: BTreeMap<ToolName, Arc<RegisteredTool>>,
}

impl LocalToolset {
    pub(crate) fn build(registrations: Vec<ToolRegistration>) -> Result<Self, ToolError> {
        let mut tools = BTreeMap::new();
        for registration in registrations {
            let registration = registration.into_registered();
            let name = registration.info().name.clone();
            if tools.insert(name.clone(), Arc::new(registration)).is_some() {
                return Err(ToolError::DuplicateName { name });
            }
        }
        Ok(Self { tools })
    }
}

impl ToolsetBackend for LocalToolset {
    type Handler = handler::LocalToolHandler;

    fn list_tools(
        &self,
    ) -> impl std::future::Future<Output = Result<Vec<ToolInfo>, ToolError>> + Send + '_ {
        std::future::ready(Ok(self
            .tools
            .values()
            .map(|entry| entry.info().clone())
            .collect()))
    }

    fn tool_handler(
        &self,
        name: ToolName,
    ) -> impl std::future::Future<Output = Result<Self::Handler, ToolError>> + Send + '_ {
        let handler = self
            .tools
            .get(&name)
            .map(|registration| handler::LocalToolHandler::new(Arc::clone(registration)))
            .ok_or(ToolError::UnknownTool { name });
        std::future::ready(handler)
    }

    fn shutdown(&self) -> impl std::future::Future<Output = Result<(), ToolError>> + Send + '_ {
        std::future::ready(Ok(()))
    }
}