vv-agent 0.6.2

VectorVein agent runtime, SDK, CLI, tools, and workspace backends
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

use serde_json::Value;

use super::jsonrpc::{JsonRpcError, JsonRpcErrorBody, RequestId};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AppServerErrorCode {
    ServerOverloaded,
    InvalidRequest,
    MethodNotFound,
    InvalidParams,
    InternalError,
    NotInitialized,
    AlreadyInitialized,
    ExperimentalApiRequired,
    UnsupportedMethod,
}

impl AppServerErrorCode {
    pub fn code(self) -> i64 {
        match self {
            Self::ServerOverloaded => -32001,
            Self::InvalidRequest => -32600,
            Self::MethodNotFound => -32601,
            Self::InvalidParams => -32602,
            Self::InternalError => -32603,
            Self::NotInitialized => -32010,
            Self::AlreadyInitialized => -32011,
            Self::ExperimentalApiRequired => -32012,
            Self::UnsupportedMethod => -32013,
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct AppServerError {
    code: AppServerErrorCode,
    message: String,
    data: Option<Value>,
}

impl AppServerError {
    pub fn new(code: AppServerErrorCode, message: impl Into<String>) -> Self {
        Self {
            code,
            message: message.into(),
            data: None,
        }
    }

    pub fn invalid_params(message: impl Into<String>) -> Self {
        Self::new(AppServerErrorCode::InvalidParams, message)
    }

    pub fn invalid_request(message: impl Into<String>) -> Self {
        Self::new(AppServerErrorCode::InvalidRequest, message)
    }

    pub fn internal(message: impl Into<String>) -> Self {
        Self::new(AppServerErrorCode::InternalError, message)
    }

    pub fn not_initialized() -> Self {
        Self::new(AppServerErrorCode::NotInitialized, "Not initialized")
    }

    pub fn already_initialized() -> Self {
        Self::new(
            AppServerErrorCode::AlreadyInitialized,
            "Already initialized",
        )
    }

    pub fn server_overloaded() -> Self {
        Self::new(
            AppServerErrorCode::ServerOverloaded,
            "Server overloaded; retry later.",
        )
    }

    pub fn unsupported_method(method: impl Into<String>) -> Self {
        let method = method.into();
        Self::new(
            AppServerErrorCode::UnsupportedMethod,
            format!("Unsupported App Server method: {method}"),
        )
        .with_data(serde_json::json!({ "method": method }))
    }

    pub fn with_data(mut self, data: Value) -> Self {
        self.data = Some(data);
        self
    }

    pub fn code(&self) -> AppServerErrorCode {
        self.code
    }

    pub fn message(&self) -> &str {
        &self.message
    }

    pub fn into_json_rpc_error(self, id: RequestId) -> JsonRpcError {
        JsonRpcError {
            id,
            error: JsonRpcErrorBody {
                code: self.code.code(),
                message: self.message,
                data: self.data,
            },
        }
    }
}