bote 0.90.0

MCP core service — JSON-RPC 2.0 protocol, tool registry, audit integration, and TypeScript bridge
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
141
142
143
144
145
146
147
148
149
150
151
152

use thiserror::Error;

#[derive(Debug, Error)]
#[non_exhaustive]
pub enum BoteError {
    #[error("tool not found: {0}")]
    ToolNotFound(String),
    #[error("invalid params for tool '{tool}': {reason}")]
    InvalidParams { tool: String, reason: String },
    #[error("tool execution failed: {tool} — {reason}")]
    ExecFailed { tool: String, reason: String },
    #[error("protocol error: {0}")]
    Protocol(String),
    #[error("parse error: {0}")]
    Parse(String),
    #[error("transport closed")]
    TransportClosed,
    #[error("transport bind failed: {0}")]
    BindFailed(String),
    #[error("request cancelled: {0}")]
    RequestCancelled(String),
    #[error("schema violation for tool '{tool}': {}", violations.join("; "))]
    SchemaViolation {
        tool: String,
        violations: Vec<String>,
    },
    #[error("sandbox error for tool '{tool}': {reason}")]
    SandboxError { tool: String, reason: String },
    #[error(transparent)]
    Json(#[from] serde_json::Error),
    #[error(transparent)]
    Io(#[from] std::io::Error),
}

impl BoteError {
    /// Convert to a JSON-RPC error code.
    #[inline]
    #[must_use]
    pub fn rpc_code(&self) -> i32 {
        match self {
            Self::Parse(_) => -32700,
            Self::Protocol(_) => -32600,
            Self::ToolNotFound(_) => -32601,
            Self::InvalidParams { .. } => -32602,
            Self::ExecFailed { .. } => -32000,
            Self::TransportClosed => -32003,
            Self::BindFailed(_) => -32003,
            Self::RequestCancelled(_) => -32800,
            Self::SchemaViolation { .. } => -32602,
            Self::SandboxError { .. } => -32000,
            Self::Json(_) => -32700,
            Self::Io(_) => -32603,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn rpc_codes_all_variants() {
        assert_eq!(BoteError::Parse("bad".into()).rpc_code(), -32700);
        assert_eq!(BoteError::Protocol("bad".into()).rpc_code(), -32600);
        assert_eq!(BoteError::ToolNotFound("x".into()).rpc_code(), -32601);
        assert_eq!(
            BoteError::InvalidParams {
                tool: "x".into(),
                reason: "y".into()
            }
            .rpc_code(),
            -32602
        );
        assert_eq!(
            BoteError::ExecFailed {
                tool: "x".into(),
                reason: "y".into()
            }
            .rpc_code(),
            -32000
        );
        assert_eq!(BoteError::TransportClosed.rpc_code(), -32003);
        assert_eq!(
            BoteError::BindFailed("port in use".into()).rpc_code(),
            -32003
        );
        assert_eq!(
            BoteError::RequestCancelled("req-1".into()).rpc_code(),
            -32800
        );

        let io_err = std::io::Error::new(std::io::ErrorKind::BrokenPipe, "broken");
        assert_eq!(BoteError::Io(io_err).rpc_code(), -32603);
    }

    #[test]
    fn display_messages() {
        assert_eq!(
            BoteError::ToolNotFound("foo".into()).to_string(),
            "tool not found: foo"
        );
        assert_eq!(
            BoteError::InvalidParams {
                tool: "t".into(),
                reason: "r".into()
            }
            .to_string(),
            "invalid params for tool 't': r"
        );
        assert_eq!(
            BoteError::ExecFailed {
                tool: "t".into(),
                reason: "r".into()
            }
            .to_string(),
            "tool execution failed: t — r"
        );
        assert_eq!(
            BoteError::Protocol("bad".into()).to_string(),
            "protocol error: bad"
        );
        assert_eq!(
            BoteError::Parse("bad".into()).to_string(),
            "parse error: bad"
        );
        assert_eq!(BoteError::TransportClosed.to_string(), "transport closed");
        assert_eq!(
            BoteError::BindFailed("port in use".into()).to_string(),
            "transport bind failed: port in use"
        );
        assert_eq!(
            BoteError::RequestCancelled("req-1".into()).to_string(),
            "request cancelled: req-1"
        );
    }

    #[test]
    fn json_error_from_serde() {
        let err: BoteError = serde_json::from_str::<serde_json::Value>("not json")
            .unwrap_err()
            .into();
        assert_eq!(err.rpc_code(), -32700);
        assert!(!err.to_string().is_empty());
    }

    #[test]
    fn io_error_from_std() {
        let err: BoteError = std::io::Error::new(std::io::ErrorKind::NotFound, "gone").into();
        assert_eq!(err.rpc_code(), -32603);
        assert!(err.to_string().contains("gone"));
    }
}