1use super::ErrorKind;
4
5pub const SESSION_NOT_LOADED_CODE: i64 = -32024;
8
9pub const SESSION_STREAM_MISMATCH_CODE: i64 = -32025;
13
14#[derive(Debug, Clone, Copy, PartialEq, Eq)]
23#[non_exhaustive]
24pub enum ErrorCode {
25 ParseError,
27 InvalidRequest,
29 MethodNotFound,
31 InvalidParams,
33 Internal,
35 Overloaded,
37 InputTooLarge,
39 CapabilityRequired,
41 NotFound,
43 Interrupted,
45 Cancelled,
47 SessionNotFound,
49 SessionInUse,
51 SessionAmbiguous,
53 ForkBoundaryInvalid,
55 SessionNotLoaded,
57 SessionStreamMismatch,
60 WorkspaceNotTrusted,
62 CommandRejected,
64 Backpressured,
66 SkillNotFound,
69 ComputerUseUnavailable,
71 MarketplaceNotFound,
73 PluginNotFound,
75 MarketplaceAlreadyExists,
77 PluginMutationsDisabled,
79 UploadNotFound,
82 ViewTruncated,
84 OutputUnavailable,
88 Boundary,
90 ApprovalNotFound,
92 ApprovalAlreadyResolved,
94 ApprovalChoiceInvalid,
96 ApprovalRequirementStale,
98 ApprovalReviewerUnavailable,
100 UserInputNotFound,
102 UserInputAlreadySettled,
104 UserInputAnswerInvalid,
106 MissingAnchor,
108 PrunedPrefix,
110 WrongStream,
112 UnknownStream,
114 UnknownProjection,
116 AdmissionNotFound,
118 AdmissionAlreadyResolved,
120 AdmissionChoiceInvalid,
122}
123
124#[derive(Clone, Copy)]
125struct ErrorCodeDefinition {
126 code: i64,
127 kind: ErrorKind,
128 override_kinds: &'static [ErrorKind],
129 retryable: Option<bool>,
130 experimental: bool,
131}
132
133impl ErrorCodeDefinition {
134 const fn new(
135 code: i64,
136 kind: ErrorKind,
137 override_kinds: &'static [ErrorKind],
138 retryable: Option<bool>,
139 ) -> Self {
140 Self {
141 code,
142 kind,
143 override_kinds,
144 retryable,
145 experimental: false,
146 }
147 }
148
149 const fn experimental(code: i64, kind: ErrorKind) -> Self {
152 Self {
153 code,
154 kind,
155 override_kinds: &[],
156 retryable: Some(false),
157 experimental: true,
158 }
159 }
160}
161
162const fn fatal(code: i64, kind: ErrorKind) -> ErrorCodeDefinition {
165 ErrorCodeDefinition::new(code, kind, &[], Some(false))
166}
167
168const fn drains(code: i64, kind: ErrorKind) -> ErrorCodeDefinition {
171 ErrorCodeDefinition::new(code, kind, &[], Some(true))
172}
173
174const fn preempted(code: i64, kind: ErrorKind) -> ErrorCodeDefinition {
177 ErrorCodeDefinition::new(code, kind, &[], None)
178}
179
180impl ErrorCode {
181 pub const ALL: [Self; 46] = [
186 Self::ParseError,
187 Self::InvalidRequest,
188 Self::MethodNotFound,
189 Self::InvalidParams,
190 Self::Internal,
191 Self::Overloaded,
192 Self::InputTooLarge,
193 Self::CapabilityRequired,
194 Self::NotFound,
195 Self::Interrupted,
196 Self::Cancelled,
197 Self::SessionNotFound,
198 Self::SessionInUse,
199 Self::SessionAmbiguous,
200 Self::ForkBoundaryInvalid,
201 Self::SessionNotLoaded,
202 Self::SessionStreamMismatch,
203 Self::WorkspaceNotTrusted,
204 Self::CommandRejected,
205 Self::Backpressured,
206 Self::SkillNotFound,
207 Self::ComputerUseUnavailable,
208 Self::MarketplaceNotFound,
209 Self::PluginNotFound,
210 Self::MarketplaceAlreadyExists,
211 Self::PluginMutationsDisabled,
212 Self::UploadNotFound,
213 Self::ViewTruncated,
214 Self::OutputUnavailable,
215 Self::Boundary,
216 Self::ApprovalNotFound,
217 Self::ApprovalAlreadyResolved,
218 Self::ApprovalChoiceInvalid,
219 Self::ApprovalRequirementStale,
220 Self::ApprovalReviewerUnavailable,
221 Self::UserInputNotFound,
222 Self::UserInputAlreadySettled,
223 Self::UserInputAnswerInvalid,
224 Self::MissingAnchor,
225 Self::PrunedPrefix,
226 Self::WrongStream,
227 Self::UnknownStream,
228 Self::UnknownProjection,
229 Self::AdmissionNotFound,
230 Self::AdmissionAlreadyResolved,
231 Self::AdmissionChoiceInvalid,
232 ];
233
234 const fn definition(self) -> ErrorCodeDefinition {
241 match self {
242 Self::ParseError => fatal(-32700, ErrorKind::ParseError),
243 Self::InvalidRequest => ErrorCodeDefinition::new(
244 -32600,
245 ErrorKind::InvalidRequest,
246 &[ErrorKind::NotInitialized, ErrorKind::AlreadyInitialized],
247 Some(false),
248 ),
249 Self::MethodNotFound => ErrorCodeDefinition::new(
250 -32601,
251 ErrorKind::MethodNotFound,
252 &[ErrorKind::ExperimentalRequired],
253 Some(false),
254 ),
255 Self::InvalidParams => ErrorCodeDefinition::new(
256 -32602,
257 ErrorKind::InvalidParams,
258 &[ErrorKind::ExperimentalRequired],
259 Some(false),
260 ),
261 Self::Internal => ErrorCodeDefinition::new(
262 -32603,
263 ErrorKind::Internal,
264 &[
265 ErrorKind::PageEventTooLarge,
266 ErrorKind::OutputResultTooLarge,
267 ],
268 Some(false),
269 ),
270 Self::Overloaded => drains(-32001, ErrorKind::Overloaded),
271 Self::InputTooLarge => fatal(-32002, ErrorKind::InputTooLarge),
272 Self::CapabilityRequired => fatal(-32010, ErrorKind::CapabilityRequired),
273 Self::NotFound => fatal(-32011, ErrorKind::NotFound),
274 Self::Interrupted => preempted(-32013, ErrorKind::Interrupted),
275 Self::Cancelled => preempted(-32014, ErrorKind::Cancelled),
276 Self::SessionNotFound => fatal(-32020, ErrorKind::SessionNotFound),
277 Self::SessionInUse => fatal(-32021, ErrorKind::SessionInUse),
278 Self::SessionAmbiguous => fatal(-32022, ErrorKind::SessionAmbiguous),
279 Self::ForkBoundaryInvalid => fatal(-32023, ErrorKind::ForkBoundaryInvalid),
280 Self::SessionNotLoaded => fatal(SESSION_NOT_LOADED_CODE, ErrorKind::SessionNotLoaded),
281 Self::SessionStreamMismatch => fatal(
282 SESSION_STREAM_MISMATCH_CODE,
283 ErrorKind::SessionStreamMismatch,
284 ),
285 Self::WorkspaceNotTrusted => {
286 ErrorCodeDefinition::experimental(-32029, ErrorKind::WorkspaceNotTrusted)
287 }
288 Self::CommandRejected => fatal(-32030, ErrorKind::CommandRejected),
289 Self::Backpressured => drains(-32031, ErrorKind::Backpressured),
290 Self::SkillNotFound => fatal(-32032, ErrorKind::SkillNotFound),
291 Self::ComputerUseUnavailable => fatal(-32033, ErrorKind::ComputerUseUnavailable),
292 Self::MarketplaceNotFound => fatal(-32034, ErrorKind::MarketplaceNotFound),
293 Self::PluginNotFound => fatal(-32035, ErrorKind::PluginNotFound),
294 Self::MarketplaceAlreadyExists => fatal(-32036, ErrorKind::MarketplaceAlreadyExists),
295 Self::PluginMutationsDisabled => fatal(-32037, ErrorKind::PluginMutationsDisabled),
296 Self::UploadNotFound => fatal(-32038, ErrorKind::UploadNotFound),
297 Self::ViewTruncated => fatal(-32040, ErrorKind::ViewTruncated),
298 Self::OutputUnavailable => fatal(-32041, ErrorKind::OutputUnavailable),
299 Self::Boundary => ErrorCodeDefinition::new(
300 -32042,
301 ErrorKind::BoundaryPruned,
302 &[ErrorKind::BoundaryUnusable, ErrorKind::NoBoundary],
303 Some(false),
304 ),
305 Self::ApprovalNotFound => fatal(-32050, ErrorKind::ApprovalNotFound),
306 Self::ApprovalAlreadyResolved => fatal(-32051, ErrorKind::ApprovalAlreadyResolved),
307 Self::ApprovalChoiceInvalid => fatal(-32052, ErrorKind::ApprovalChoiceInvalid),
308 Self::ApprovalRequirementStale => fatal(-32053, ErrorKind::ApprovalRequirementStale),
309 Self::ApprovalReviewerUnavailable => {
310 fatal(-32054, ErrorKind::ApprovalReviewerUnavailable)
311 }
312 Self::UserInputNotFound => fatal(-32055, ErrorKind::UserInputNotFound),
313 Self::UserInputAlreadySettled => fatal(-32056, ErrorKind::UserInputAlreadySettled),
314 Self::UserInputAnswerInvalid => fatal(-32057, ErrorKind::UserInputAnswerInvalid),
315 Self::MissingAnchor => {
316 ErrorCodeDefinition::experimental(-32060, ErrorKind::MissingAnchor)
317 }
318 Self::PrunedPrefix => {
319 ErrorCodeDefinition::experimental(-32061, ErrorKind::PrunedPrefix)
320 }
321 Self::WrongStream => ErrorCodeDefinition::experimental(-32062, ErrorKind::WrongStream),
322 Self::UnknownStream => {
323 ErrorCodeDefinition::experimental(-32063, ErrorKind::UnknownStream)
324 }
325 Self::UnknownProjection => {
326 ErrorCodeDefinition::experimental(-32064, ErrorKind::UnknownProjection)
327 }
328 Self::AdmissionNotFound => {
329 ErrorCodeDefinition::experimental(-32070, ErrorKind::AdmissionNotFound)
330 }
331 Self::AdmissionAlreadyResolved => {
332 ErrorCodeDefinition::experimental(-32071, ErrorKind::AdmissionAlreadyResolved)
333 }
334 Self::AdmissionChoiceInvalid => {
335 ErrorCodeDefinition::experimental(-32072, ErrorKind::AdmissionChoiceInvalid)
336 }
337 }
338 }
339
340 #[must_use]
342 pub const fn code(self) -> i64 {
343 self.definition().code
344 }
345
346 #[must_use]
348 pub const fn kind(self) -> ErrorKind {
349 self.definition().kind
350 }
351
352 #[must_use]
357 pub const fn override_kinds(self) -> &'static [ErrorKind] {
358 self.definition().override_kinds
359 }
360
361 #[must_use]
364 pub const fn retryable(self) -> Option<bool> {
365 self.definition().retryable
366 }
367
368 #[must_use]
370 pub const fn is_experimental(self) -> bool {
371 self.definition().experimental
372 }
373}