behest 0.2.1

A Rust-native cloud agent runtime with typed tools, pluggable memory, queues, and observability.
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

//! ContextService gRPC implementation.

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

use crate::grpc::pb::{
    BuildContextRequest, BuildContextResponse, ListContextAdaptersRequest,
    ListContextAdaptersResponse, context_service_server::ContextService,
};

use std::sync::Arc;

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

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

#[tonic::async_trait]
impl ContextService for GrpcContextService {
    async fn build_context(
        &self,
        request: Request<BuildContextRequest>,
    ) -> Result<Response<BuildContextResponse>, Status> {
        let req = request.into_inner();

        let session_id = Uuid::parse_str(&req.session_id)
            .map_err(|e| Status::invalid_argument(format!("invalid session_id: {e}")))?;

        let context = self.state.runtime.context();

        let output = context
            .build_context(
                self.state.runtime.store(),
                session_id,
                Some(&req.user_message),
            )
            .await
            .map_err(|e| super::runtime_error_to_status(&e))?;

        let messages: Vec<crate::grpc::pb::Message> = output
            .messages()
            .iter()
            .map(crate::grpc::session::message_to_proto)
            .collect();

        Ok(Response::new(BuildContextResponse { messages }))
    }

    async fn list_context_adapters(
        &self,
        _request: Request<ListContextAdaptersRequest>,
    ) -> Result<Response<ListContextAdaptersResponse>, Status> {
        let context = self.state.runtime.context();
        let adapter_names: Vec<String> = context.adapter_names().map(str::to_owned).collect();

        Ok(Response::new(ListContextAdaptersResponse { adapter_names }))
    }
}