Struct KitError 

pub struct KitError { /* private fields */ }

An opaque, safely formatted failure with bounded normalized evidence.

Messages supplied by callers must already be redacted. Never include native identities, routes, credentials, storage keys, payloads or foreign prose.

use agents_kit::{KitError, error::{ErrorKind, Operation, ErrorPhase, ErrorDetail}};
let error = KitError::integration("model authentication was rejected")
    .with_context(Operation::Prompt, ErrorPhase::ModelGeneration)
    .with_detail(ErrorDetail::AuthenticationRejected)
    .with_http_status(401);
assert_eq!(error.kind(), ErrorKind::Integration);
assert_eq!(error.http_status(), Some(401));

Runtime failures cannot be reconstructed from untrusted serialized messages.

let error = agents_kit::KitError::integration("safe failure");
let _ = serde_json::to_string(&error);

Implementations

impl KitError

pub fn new(kind: ErrorKind, safe_message: impl Into<String>) -> Self

Constructs a classified failure with already-redacted caller context.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::new(ErrorKind::Integration, "safe dependency failure");
assert_eq!(error.kind(), ErrorKind::Integration);

pub fn invalid_config(message: impl Into<String>) -> Self

Creates an invalid-configuration failure with safe context.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::invalid_config("safe failure context");
assert_eq!(error.kind(), ErrorKind::InvalidConfig);

pub fn invalid_input(message: impl Into<String>) -> Self

Creates an invalid-input failure with safe context.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::invalid_input("safe failure context");
assert_eq!(error.kind(), ErrorKind::InvalidInput);

pub fn not_found(message: impl Into<String>) -> Self

Creates a proven missing-portable-resource failure.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::not_found("safe failure context");
assert_eq!(error.kind(), ErrorKind::NotFound);

pub fn conflict(message: impl Into<String>) -> Self

Creates a durable-fact conflict.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::conflict("safe failure context");
assert_eq!(error.kind(), ErrorKind::Conflict);

pub fn closed(message: impl Into<String>) -> Self

Creates an owning-lifecycle closure failure.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::closed("safe failure context");
assert_eq!(error.kind(), ErrorKind::Closed);

pub fn busy(message: impl Into<String>) -> Self

Creates a busy-admission failure.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::busy("safe failure context");
assert_eq!(error.kind(), ErrorKind::Busy);

pub fn cancelled(message: impl Into<String>) -> Self

Creates a durable Agent cancellation failure.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::cancelled("safe failure context");
assert_eq!(error.kind(), ErrorKind::Cancelled);

pub fn timeout(message: impl Into<String>) -> Self

Creates a local deadline failure; attach the known owner and duration.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::timeout("safe failure context");
assert_eq!(error.kind(), ErrorKind::Timeout);

pub fn unsupported(message: impl Into<String>) -> Self

Creates an unsupported-semantics failure.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::unsupported("safe failure context");
assert_eq!(error.kind(), ErrorKind::Unsupported);

pub fn not_yet_implemented(message: impl Into<String>) -> Self

Creates an incomplete-adapter failure.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::not_yet_implemented("safe failure context");
assert_eq!(error.kind(), ErrorKind::NotYetImplemented);

pub fn protocol(message: impl Into<String>) -> Self

Creates a malformed or contradictory protocol failure.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::protocol("safe failure context");
assert_eq!(error.kind(), ErrorKind::Protocol);

pub fn invalid_state(message: impl Into<String>) -> Self

Creates an invalid-owned-state failure.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::invalid_state("safe failure context");
assert_eq!(error.kind(), ErrorKind::InvalidState);

pub fn integration(message: impl Into<String>) -> Self

Creates a dependency execution failure.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::integration("safe failure context");
assert_eq!(error.kind(), ErrorKind::Integration);

pub fn with_context(self, operation: Operation, phase: ErrorPhase) -> Self

Attaches the caller operation and detecting phase without changing evidence.

use agents_kit::KitError;
use agents_kit::error::{Operation, ErrorPhase};
let error = KitError::protocol("missing reply").with_context(Operation::Prompt, ErrorPhase::ResponseDecode);
assert_eq!(error.context().phase, ErrorPhase::ResponseDecode);

pub fn with_detail(self, detail: ErrorDetail) -> Self

Attaches sourced portable evidence without changing the broad category.

use agents_kit::KitError;
use agents_kit::error::{ErrorDetail};
let error = KitError::protocol("missing reply").with_detail(ErrorDetail::MissingData);
assert_eq!(error.detail(), Some(&ErrorDetail::MissingData));

pub fn with_http_status(self, status: u16) -> Self

Attaches an observed HTTP status, never an inferred status.

use agents_kit::KitError;
let error = KitError::integration("rejected request").with_http_status(403);
assert_eq!(error.http_status(), Some(403));

pub fn with_cause(self, cause: Self) -> Self

Attaches a normalized causal failure, separately from cleanup failures.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
let error = KitError::integration("generation failed").with_cause(KitError::timeout("dependency deadline elapsed"));
assert_eq!(error.cause().unwrap().kind(), ErrorKind::Timeout);

pub fn with_supplementary(self, error: Self) -> Self

Appends independent cleanup or earlier-attempt evidence in observation order.

use agents_kit::KitError;
let error = KitError::protocol("invalid reply").with_supplementary(KitError::integration("cleanup failed"));
assert_eq!(error.supplementary().len(), 1);

pub fn kind(&self) -> ErrorKind

Returns the broad portable category.

use agents_kit::KitError;
use agents_kit::error::{ErrorKind};
assert_eq!(KitError::closed("agent shut down").kind(), ErrorKind::Closed);

pub fn context(&self) -> &ErrorContext

Returns the caller operation and detecting phase.

use agents_kit::KitError;
use agents_kit::error::{Operation, ErrorPhase};
let error = KitError::protocol("invalid reply").with_context(Operation::Prompt, ErrorPhase::ResponseDecode);
assert_eq!(error.context().operation, Operation::Prompt);

pub fn detail(&self) -> Option<&ErrorDetail>

Returns narrower evidence when a detector established it.

use agents_kit::KitError;
use agents_kit::error::{ErrorDetail};
let error = KitError::integration("output truncated").with_detail(ErrorDetail::OutputLimit);
assert_eq!(error.detail(), Some(&ErrorDetail::OutputLimit));

pub fn http_status(&self) -> Option<u16>

Returns the actual observed HTTP status.

use agents_kit::KitError;
assert_eq!(KitError::integration("no HTTP response").http_status(), None);

pub fn cause(&self) -> Option<&Self>

Returns the normalized causal failure.

use agents_kit::KitError;
assert!(KitError::invalid_input("empty prompt").cause().is_none());

pub fn supplementary(&self) -> &[Self]

Returns independent supplementary failures in observation order.

use agents_kit::KitError;
assert!(KitError::invalid_input("empty prompt").supplementary().is_empty());

pub fn diagnostics_truncated(&self) -> bool

Reports whether any retained diagnostic tree evidence was truncated.

use agents_kit::KitError;
let error = KitError::integration("x".repeat(5000));
assert!(error.diagnostics_truncated());
assert_eq!(error.message().len(), 4096);

pub fn message(&self) -> &str

Returns bounded, already-redacted caller context.

use agents_kit::KitError;
let error = KitError::invalid_input("prompt must be nonempty");
assert_eq!(error.message(), "prompt must be nonempty");

Trait Implementations

impl Clone for KitError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KitError

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

Formats the value using the given formatter.

impl Display for KitError

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

Formats the value using the given formatter.

impl Error for KitError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for KitError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for KitError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ToolError> for KitError

fn from(source: ToolError) -> Self

Converts to this type from the input type.