senno 0.5.0

Wits for your backend: provider-agnostic LLM client and streaming tool-calling agent engine, Vertex AI first (Gemini + Claude on Vertex), with built-in history compaction.
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

/// The one error type senno returns. Hosts convert at the boundary
/// (e.g. `impl From<senno::Error> for AppError`).
#[derive(Debug, Clone, thiserror::Error)]
pub enum Error {
    /// An upstream service (model API, token endpoint) failed.
    #[error("{provider}: {detail}")]
    Provider {
        provider: String,
        detail: String,
        retryable: bool,
    },

    /// The model's output could not be used (no tool call, malformed args).
    #[error("bad response: {0}")]
    BadResponse(String),

    /// Local misconfiguration (missing key, bad env, invalid builder input).
    #[error("config: {0}")]
    Config(String),

    /// A tool invoked by an agent flow failed.
    #[error("tool {name}: {detail}")]
    Tool { name: String, detail: String },

    /// Anything else.
    #[error("{0}")]
    Internal(String),
}

impl Error {
    pub fn provider(provider: impl Into<String>, detail: impl Into<String>) -> Self {
        Self::Provider {
            provider: provider.into(),
            detail: detail.into(),
            retryable: true,
        }
    }

    pub fn provider_permanent(provider: impl Into<String>, detail: impl Into<String>) -> Self {
        Self::Provider {
            provider: provider.into(),
            detail: detail.into(),
            retryable: false,
        }
    }

    pub fn bad_response(detail: impl Into<String>) -> Self {
        Self::BadResponse(detail.into())
    }

    pub fn config(detail: impl Into<String>) -> Self {
        Self::Config(detail.into())
    }

    pub fn tool(name: impl Into<String>, detail: impl Into<String>) -> Self {
        Self::Tool {
            name: name.into(),
            detail: detail.into(),
        }
    }

    pub fn internal(detail: impl Into<String>) -> Self {
        Self::Internal(detail.into())
    }

    pub fn is_provider_error(&self) -> bool {
        matches!(self, Self::Provider { .. })
    }

    pub fn is_bad_response(&self) -> bool {
        matches!(self, Self::BadResponse(_))
    }

    /// Whether retrying the same call may succeed. Only transient upstream
    /// failures qualify.
    pub fn is_retryable(&self) -> bool {
        matches!(
            self,
            Self::Provider {
                retryable: true,
                ..
            }
        )
    }
}

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

    #[test]
    fn provider_display_keeps_upstream_and_detail() {
        let e = Error::provider("vertex-ai", "API error (500): boom");
        assert_eq!(e.to_string(), "vertex-ai: API error (500): boom");
        assert!(e.is_provider_error());
        assert!(e.is_retryable());
    }

    #[test]
    fn permanent_provider_error_is_not_retryable() {
        let e = Error::provider_permanent("gcp-oauth2", "invalid_grant");
        assert!(e.is_provider_error());
        assert!(!e.is_retryable());
    }

    #[test]
    fn bad_response_is_flagged_and_not_retryable() {
        let e = Error::bad_response("model returned no tool call");
        assert!(e.is_bad_response());
        assert!(!e.is_retryable());
    }
}