1use super::ErrorKind;
4
5pub const SESSION_NOT_LOADED_CODE: i64 = -32024;
8
9pub const SESSION_STREAM_MISMATCH_CODE: i64 = -32025;
13
14pub const LIMITS_ABOVE_MAX_CODE: i64 = -32028;
18
19#[derive(Debug, Clone, Copy, PartialEq, Eq)]
28#[non_exhaustive]
29pub enum ErrorCode {
30 ParseError,
32 InvalidRequest,
34 MethodNotFound,
36 InvalidParams,
38 Internal,
40 Overloaded,
42 InputTooLarge,
44 CapabilityRequired,
46 NotFound,
48 Interrupted,
50 Cancelled,
52 SessionNotFound,
54 SessionInUse,
56 SessionAmbiguous,
58 ForkBoundaryInvalid,
60 SessionNotLoaded,
62 SessionStreamMismatch,
65 LimitsAboveMax,
68 WorkspaceNotTrusted,
70 CommandRejected,
72 Backpressured,
74 SkillNotFound,
77 ComputerUseUnavailable,
79 MarketplaceNotFound,
81 PluginNotFound,
83 MarketplaceAlreadyExists,
85 PluginMutationsDisabled,
87 UploadNotFound,
90 ViewTruncated,
92 OutputUnavailable,
96 Boundary,
98 ApprovalNotFound,
100 ApprovalAlreadyResolved,
102 ApprovalChoiceInvalid,
104 ApprovalRequirementStale,
106 ApprovalReviewerUnavailable,
108 UserInputNotFound,
110 UserInputAlreadySettled,
112 UserInputAnswerInvalid,
114 MissingAnchor,
116 PrunedPrefix,
118 WrongStream,
120 UnknownStream,
122 UnknownProjection,
124 AdmissionNotFound,
126 AdmissionAlreadyResolved,
128 AdmissionChoiceInvalid,
130}
131
132#[derive(Clone, Copy)]
133struct ErrorCodeDefinition {
134 code: i64,
135 kind: ErrorKind,
136 override_kinds: &'static [ErrorKind],
137 retryable: Option<bool>,
138 experimental: bool,
139}
140
141impl ErrorCodeDefinition {
142 const fn new(
143 code: i64,
144 kind: ErrorKind,
145 override_kinds: &'static [ErrorKind],
146 retryable: Option<bool>,
147 ) -> Self {
148 Self {
149 code,
150 kind,
151 override_kinds,
152 retryable,
153 experimental: false,
154 }
155 }
156
157 const fn experimental(code: i64, kind: ErrorKind) -> Self {
160 Self {
161 code,
162 kind,
163 override_kinds: &[],
164 retryable: Some(false),
165 experimental: true,
166 }
167 }
168}
169
170const fn fatal(code: i64, kind: ErrorKind) -> ErrorCodeDefinition {
173 ErrorCodeDefinition::new(code, kind, &[], Some(false))
174}
175
176const fn drains(code: i64, kind: ErrorKind) -> ErrorCodeDefinition {
179 ErrorCodeDefinition::new(code, kind, &[], Some(true))
180}
181
182const fn preempted(code: i64, kind: ErrorKind) -> ErrorCodeDefinition {
185 ErrorCodeDefinition::new(code, kind, &[], None)
186}
187
188impl ErrorCode {
189 pub const ALL: [Self; 47] = [
193 Self::ParseError,
194 Self::InvalidRequest,
195 Self::MethodNotFound,
196 Self::InvalidParams,
197 Self::Internal,
198 Self::Overloaded,
199 Self::InputTooLarge,
200 Self::CapabilityRequired,
201 Self::NotFound,
202 Self::Interrupted,
203 Self::Cancelled,
204 Self::SessionNotFound,
205 Self::SessionInUse,
206 Self::SessionAmbiguous,
207 Self::ForkBoundaryInvalid,
208 Self::SessionNotLoaded,
209 Self::SessionStreamMismatch,
210 Self::LimitsAboveMax,
211 Self::WorkspaceNotTrusted,
212 Self::CommandRejected,
213 Self::Backpressured,
214 Self::SkillNotFound,
215 Self::ComputerUseUnavailable,
216 Self::MarketplaceNotFound,
217 Self::PluginNotFound,
218 Self::MarketplaceAlreadyExists,
219 Self::PluginMutationsDisabled,
220 Self::UploadNotFound,
221 Self::ViewTruncated,
222 Self::OutputUnavailable,
223 Self::Boundary,
224 Self::ApprovalNotFound,
225 Self::ApprovalAlreadyResolved,
226 Self::ApprovalChoiceInvalid,
227 Self::ApprovalRequirementStale,
228 Self::ApprovalReviewerUnavailable,
229 Self::UserInputNotFound,
230 Self::UserInputAlreadySettled,
231 Self::UserInputAnswerInvalid,
232 Self::MissingAnchor,
233 Self::PrunedPrefix,
234 Self::WrongStream,
235 Self::UnknownStream,
236 Self::UnknownProjection,
237 Self::AdmissionNotFound,
238 Self::AdmissionAlreadyResolved,
239 Self::AdmissionChoiceInvalid,
240 ];
241
242 const fn definition(self) -> ErrorCodeDefinition {
249 match self {
250 Self::ParseError => fatal(-32700, ErrorKind::ParseError),
251 Self::InvalidRequest => ErrorCodeDefinition::new(
252 -32600,
253 ErrorKind::InvalidRequest,
254 &[ErrorKind::NotInitialized, ErrorKind::AlreadyInitialized],
255 Some(false),
256 ),
257 Self::MethodNotFound => ErrorCodeDefinition::new(
258 -32601,
259 ErrorKind::MethodNotFound,
260 &[ErrorKind::ExperimentalRequired],
261 Some(false),
262 ),
263 Self::InvalidParams => ErrorCodeDefinition::new(
264 -32602,
265 ErrorKind::InvalidParams,
266 &[ErrorKind::ExperimentalRequired],
267 Some(false),
268 ),
269 Self::Internal => ErrorCodeDefinition::new(
270 -32603,
271 ErrorKind::Internal,
272 &[
273 ErrorKind::PageEventTooLarge,
274 ErrorKind::OutputResultTooLarge,
275 ],
276 Some(false),
277 ),
278 Self::Overloaded => drains(-32001, ErrorKind::Overloaded),
279 Self::InputTooLarge => fatal(-32002, ErrorKind::InputTooLarge),
280 Self::CapabilityRequired => fatal(-32010, ErrorKind::CapabilityRequired),
281 Self::NotFound => fatal(-32011, ErrorKind::NotFound),
282 Self::Interrupted => preempted(-32013, ErrorKind::Interrupted),
283 Self::Cancelled => preempted(-32014, ErrorKind::Cancelled),
284 Self::SessionNotFound => fatal(-32020, ErrorKind::SessionNotFound),
285 Self::SessionInUse => fatal(-32021, ErrorKind::SessionInUse),
286 Self::SessionAmbiguous => fatal(-32022, ErrorKind::SessionAmbiguous),
287 Self::ForkBoundaryInvalid => fatal(-32023, ErrorKind::ForkBoundaryInvalid),
288 Self::SessionNotLoaded => fatal(SESSION_NOT_LOADED_CODE, ErrorKind::SessionNotLoaded),
289 Self::SessionStreamMismatch => fatal(
290 SESSION_STREAM_MISMATCH_CODE,
291 ErrorKind::SessionStreamMismatch,
292 ),
293 Self::LimitsAboveMax => {
294 ErrorCodeDefinition::experimental(LIMITS_ABOVE_MAX_CODE, ErrorKind::LimitsAboveMax)
295 }
296 Self::WorkspaceNotTrusted => {
297 ErrorCodeDefinition::experimental(-32029, ErrorKind::WorkspaceNotTrusted)
298 }
299 Self::CommandRejected => fatal(-32030, ErrorKind::CommandRejected),
300 Self::Backpressured => drains(-32031, ErrorKind::Backpressured),
301 Self::SkillNotFound => fatal(-32032, ErrorKind::SkillNotFound),
302 Self::ComputerUseUnavailable => fatal(-32033, ErrorKind::ComputerUseUnavailable),
303 Self::MarketplaceNotFound => fatal(-32034, ErrorKind::MarketplaceNotFound),
304 Self::PluginNotFound => fatal(-32035, ErrorKind::PluginNotFound),
305 Self::MarketplaceAlreadyExists => fatal(-32036, ErrorKind::MarketplaceAlreadyExists),
306 Self::PluginMutationsDisabled => fatal(-32037, ErrorKind::PluginMutationsDisabled),
307 Self::UploadNotFound => fatal(-32038, ErrorKind::UploadNotFound),
308 Self::ViewTruncated => fatal(-32040, ErrorKind::ViewTruncated),
309 Self::OutputUnavailable => fatal(-32041, ErrorKind::OutputUnavailable),
310 Self::Boundary => ErrorCodeDefinition::new(
311 -32042,
312 ErrorKind::BoundaryPruned,
313 &[ErrorKind::BoundaryUnusable, ErrorKind::NoBoundary],
314 Some(false),
315 ),
316 Self::ApprovalNotFound => fatal(-32050, ErrorKind::ApprovalNotFound),
317 Self::ApprovalAlreadyResolved => fatal(-32051, ErrorKind::ApprovalAlreadyResolved),
318 Self::ApprovalChoiceInvalid => fatal(-32052, ErrorKind::ApprovalChoiceInvalid),
319 Self::ApprovalRequirementStale => fatal(-32053, ErrorKind::ApprovalRequirementStale),
320 Self::ApprovalReviewerUnavailable => {
321 fatal(-32054, ErrorKind::ApprovalReviewerUnavailable)
322 }
323 Self::UserInputNotFound => fatal(-32055, ErrorKind::UserInputNotFound),
324 Self::UserInputAlreadySettled => fatal(-32056, ErrorKind::UserInputAlreadySettled),
325 Self::UserInputAnswerInvalid => fatal(-32057, ErrorKind::UserInputAnswerInvalid),
326 Self::MissingAnchor => {
327 ErrorCodeDefinition::experimental(-32060, ErrorKind::MissingAnchor)
328 }
329 Self::PrunedPrefix => {
330 ErrorCodeDefinition::experimental(-32061, ErrorKind::PrunedPrefix)
331 }
332 Self::WrongStream => ErrorCodeDefinition::experimental(-32062, ErrorKind::WrongStream),
333 Self::UnknownStream => {
334 ErrorCodeDefinition::experimental(-32063, ErrorKind::UnknownStream)
335 }
336 Self::UnknownProjection => {
337 ErrorCodeDefinition::experimental(-32064, ErrorKind::UnknownProjection)
338 }
339 Self::AdmissionNotFound => {
340 ErrorCodeDefinition::experimental(-32070, ErrorKind::AdmissionNotFound)
341 }
342 Self::AdmissionAlreadyResolved => {
343 ErrorCodeDefinition::experimental(-32071, ErrorKind::AdmissionAlreadyResolved)
344 }
345 Self::AdmissionChoiceInvalid => {
346 ErrorCodeDefinition::experimental(-32072, ErrorKind::AdmissionChoiceInvalid)
347 }
348 }
349 }
350
351 #[must_use]
353 pub const fn code(self) -> i64 {
354 self.definition().code
355 }
356
357 #[must_use]
359 pub const fn kind(self) -> ErrorKind {
360 self.definition().kind
361 }
362
363 #[must_use]
368 pub const fn override_kinds(self) -> &'static [ErrorKind] {
369 self.definition().override_kinds
370 }
371
372 #[must_use]
375 pub const fn retryable(self) -> Option<bool> {
376 self.definition().retryable
377 }
378
379 #[must_use]
381 pub const fn is_experimental(self) -> bool {
382 self.definition().experimental
383 }
384}