Enum ErrorKind 

#[non_exhaustive]
pub enum ErrorKind {
    ParseError,
    InvalidRequest,
    MethodNotFound,
    InvalidParams,
    InternalError,
    Unauthorized,
    NotFound,
    AgentDisconnected,
    RateLimit,
    StaleProtocol,
    PayloadTooLarge,
}

All KLP-defined error kinds (SPEC §2.12.9 table).

Wire-encoded verbatim as the variant name ("Unauthorized", "RateLimit", "StaleProtocol", …) to match the SPEC §2.12.9 table 1:1 — this is the one place in the codebase that breaks from the otherwise-uniform snake_case convention, because the spec doc shows PascalCase wire and we keep that contract.

#[non_exhaustive] so SPEC §2.12.9 can grow new error kinds in a future revision without forcing a wire-protocol bump — downstream Rust consumers see a compile-time nudge to add a wildcard arm.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ParseError

-32700 — request body wasn’t valid JSON.

InvalidRequest

-32600 — JSON-RPC envelope rejected (missing jsonrpc field, non-string method, etc.) OR a non-handshake method was invoked before system.handshake completed.

MethodNotFound

-32601 — method name not registered on this agent’s dispatcher.

InvalidParams

-32602 — params failed schema validation for the named method.

InternalError

-32603 — agent-side panic / unexpected failure. Always returned with a redacted message — the original error lives in the agent log.

Unauthorized

-32000 — authorization failure. The connection is authed (we know the SID/UID) but the caller isn’t allowed to do this thing: invoking a job whose manifest has user_invokable=false, killing a run_id belonging to another connection, ack-ing a notification not addressed to the caller’s PC / group / all audience.

NotFound

-32001 — referenced job_id / run_id / notification_id doesn’t exist.

AgentDisconnected

-32002 — agent isn’t connected to NATS right now, so fan-out / publish-side operations can’t be served. The client SHOULD show a transient banner and retry on the next state push.

RateLimit

-32003 — connection exceeded the 60 req/min cap. The client SHOULD back off (the agent doesn’t tell it for how long; 1 s is a safe minimum).

StaleProtocol

-32004 — handshake negotiated a protocol version that one side no longer supports. Treat as fatal: the client must upgrade (or the agent must be downgraded).

PayloadTooLarge

-32005 — message body exceeded the 1 MiB framing limit (SPEC §2.12.2). stdout_chunk payloads must be split before hitting this.

Implementations

impl ErrorKind

pub fn code(self) -> i32

JSON-RPC code field for this kind. Pre-baked so the dispatch path doesn’t accidentally drift away from the table — the only blessed mapping lives here.

pub fn default_message(self) -> &'static str

Default human-readable message. Agents may override per-call when they have a more specific phrasing; tests and the spec table use these.

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ErrorKind

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ErrorKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ErrorKind

impl Hash for ErrorKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl JsonSchema for ErrorKind

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for ErrorKind

fn eq(&self, other: &ErrorKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ErrorKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ErrorKind