oino-acp 1.0.0

ACP v1 (Agent Client Protocol) agent adapter over oino-core sessions
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

//! Adapter errors and their JSON-RPC forms.

use agent_client_protocol::Error as RpcError;
use oino_client::ClientError;

/// A failure inside the adapter.
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum AcpError {
    /// Unknown ACP session id.
    #[error("Session not found: {0}")]
    SessionNotFound(String),
    /// The request is malformed for Oino (bad config value, unknown option, …).
    #[error("{0}")]
    InvalidParams(String),
    /// Creating or opening a session failed.
    #[error("{0}")]
    Factory(String),
    /// A session command failed.
    #[error("{0}")]
    Command(String),
    /// The client rejected or failed a request the agent sent.
    #[error("client request {method} failed: {message}")]
    Client {
        /// ACP method.
        method: &'static str,
        /// Client error text.
        message: String,
    },
    /// The connection is gone.
    #[error("connection closed")]
    Closed,
    /// JSON shape mismatch between Oino and the ACP schema.
    #[error("protocol: {0}")]
    Protocol(String),
}

impl From<ClientError> for AcpError {
    fn from(error: ClientError) -> Self {
        match error {
            ClientError::Command(message) => Self::Command(message),
            ClientError::Closed => Self::Closed,
            other => Self::Protocol(other.to_string()),
        }
    }
}

impl From<serde_json::Error> for AcpError {
    fn from(error: serde_json::Error) -> Self {
        Self::Protocol(error.to_string())
    }
}

impl From<AcpError> for RpcError {
    fn from(error: AcpError) -> Self {
        let code = match &error {
            AcpError::SessionNotFound(_) => RpcError::resource_not_found(None).code,
            AcpError::InvalidParams(_) => RpcError::invalid_params().code,
            _ => RpcError::internal_error().code,
        };
        RpcError::new(code.into(), error.to_string())
    }
}