behest 0.3.3

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
134
135
136
137
138
139
140

//! ToolService gRPC implementation.
//!
//! Provides RPCs for listing, querying, invoking, registering, and
//! unregistering tools in the runtime tool registry.

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 for runtime tool registry management.
///
/// Supports listing registered tools with their JSON schema,
/// invoking tools by name, and dynamic registration/removal of
/// external tools.
pub struct GrpcToolService {
    state: Arc<super::state::GrpcState>,
}

impl GrpcToolService {
    /// Creates a new tool service backed by the given shared state.
    #[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 {}))
    }
}