behest 0.2.2

A Rust-native cloud agent runtime with typed tools, pluggable memory, queues, and observability.
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! ToolService gRPC implementation.

use tonic::{Request, Response, Status};

use crate::grpc::pb::{
    GetToolRequest, GetToolResponse, InvokeToolRequest, InvokeToolResponse, ListToolsRequest,
    ListToolsResponse, RegisterToolRequest, RegisterToolResponse, ToolInfo, UnregisterToolRequest,
    UnregisterToolResponse, tool_service_server::ToolService,
};

use std::sync::Arc;

/// gRPC tool service.
pub struct GrpcToolService {
    state: Arc<super::state::GrpcState>,
}

impl GrpcToolService {
    /// Creates a new tool service.
    #[must_use]
    pub fn new(state: Arc<super::state::GrpcState>) -> Self {
        Self { state }
    }
}

#[tonic::async_trait]
impl ToolService for GrpcToolService {
    async fn list_tools(
        &self,
        _request: Request<ListToolsRequest>,
    ) -> Result<Response<ListToolsResponse>, Status> {
        let tools: Vec<ToolInfo> = self
            .state
            .runtime
            .tools()
            .registry()
            .specs()
            .into_iter()
            .map(|spec| ToolInfo {
                name: spec.name,
                description: spec.description,
                parameters_schema: spec.parameters_schema.to_string(),
            })
            .collect();

        Ok(Response::new(ListToolsResponse { tools }))
    }

    async fn get_tool(
        &self,
        request: Request<GetToolRequest>,
    ) -> Result<Response<GetToolResponse>, Status> {
        let req = request.into_inner();
        let Some(tool) = self.state.runtime.tools().registry().get(&req.name) else {
            return Err(Status::not_found(format!("tool '{}' not found", req.name)));
        };

        let spec = tool.to_spec();
        Ok(Response::new(GetToolResponse {
            tool: Some(ToolInfo {
                name: spec.name,
                description: spec.description,
                parameters_schema: spec.parameters_schema.to_string(),
            }),
        }))
    }

    async fn invoke_tool(
        &self,
        request: Request<InvokeToolRequest>,
    ) -> Result<Response<InvokeToolResponse>, Status> {
        let req = request.into_inner();
        let Some(tool) = self.state.runtime.tools().registry().get(&req.name) else {
            return Err(Status::not_found(format!("tool '{}' not found", req.name)));
        };

        let arguments: serde_json::Value = serde_json::from_str(&req.arguments)
            .map_err(|e| Status::invalid_argument(format!("invalid JSON arguments: {e}")))?;

        let output = tool
            .execute(arguments)
            .await
            .map_err(|e| super::error_to_status(e.into()))?;

        Ok(Response::new(InvokeToolResponse {
            name: tool.name().to_owned(),
            output: output.value.to_string(),
        }))
    }

    async fn register_tool(
        &self,
        request: Request<RegisterToolRequest>,
    ) -> Result<Response<RegisterToolResponse>, Status> {
        let req = request.into_inner();

        if req.name.is_empty() {
            return Err(Status::invalid_argument("tool name must not be empty"));
        }

        let schema: serde_json::Value =
            serde_json::from_str(&req.parameters_schema).map_err(|e| {
                Status::invalid_argument(format!("invalid parameters schema JSON: {e}"))
            })?;

        let mut tool = crate::tool::ExternalTool::new(&req.name, &req.description, schema);
        if !req.endpoint.is_empty() {
            tool = tool.with_endpoint(&req.endpoint);
        }

        self.state.runtime.tools().register_tool(Arc::new(tool));

        Ok(Response::new(RegisterToolResponse {}))
    }

    async fn unregister_tool(
        &self,
        request: Request<UnregisterToolRequest>,
    ) -> Result<Response<UnregisterToolResponse>, Status> {
        let req = request.into_inner();

        if req.name.is_empty() {
            return Err(Status::invalid_argument("tool name must not be empty"));
        }

        let removed = self.state.runtime.tools().unregister_tool(&req.name);
        if removed.is_none() {
            return Err(Status::not_found(format!("tool '{}' not found", req.name)));
        }

        Ok(Response::new(UnregisterToolResponse {}))
    }
}