Enum Error 

pub enum Error {
    Io(Error),
    Json(Error),
    Pdf(String),
    DocumentNotFound(String),
    ChunkNotFound(String),
    Embedding(String),
    Indexing(String),
    Retrieval(String),
    Storage(String),
    Config(String),
    Network(String),
    Daemon(String),
    Validation(String),
    NotFound {
        resource: String,
    },
    IoMessage {
        message: String,
    },
    Parse {
        message: String,
    },
    Qdrant(String),
    Tantivy(String),
    ConfigError(String),
    WithContext {
        context: String,
        source: Box<dyn Error + Send + Sync>,
    },
    Mcp(String),
    M2ExecutionError(String),
    RateLimitExceeded,
    BudgetExceeded(f64, f64),
    M2ProtocolValidation(String),
    M2ConstraintViolation(String),
    M2FrameworkIncompatibility(String),
    ResourceExhausted(String),
    TemplateNotFound(String),
    CodeIntelligence(String),
    M2IntegrationError(String),
    Timeout(String),
    DependencyNotMet(String),
    ProtocolGenerationError(String),
    ThinkToolExecutionError(String),
    RateLimit(String),
    Authentication(String),
    Authorization(String),
}

Error types for ReasonKit Core.

This enum encompasses all error conditions that can occur during ReasonKit operations. Each variant carries context-specific information to aid in debugging and error recovery.

Example

use reasonkit::Error;

// Create specific error types
let validation_err = Error::Validation("Invalid input".to_string());
let not_found_err = Error::NotFound { resource: "document:123".to_string() };

// Add context to existing errors
let io_error = std::io::Error::new(std::io::ErrorKind::NotFound, "file missing");
let wrapped = Error::with_context("Loading config", io_error);

Variants

Io(Error)

I/O error from standard library operations.

Automatically converted from std::io::Error.

Json(Error)

JSON serialization/deserialization error.

Automatically converted from serde_json::Error.

Pdf(String)

PDF processing error.

Occurs during PDF parsing, text extraction, or page processing.

DocumentNotFound(String)

Document not found in the knowledge base.

The document ID does not exist or has been deleted.

ChunkNotFound(String)

Chunk not found within a document.

The chunk ID does not exist or the document has been re-chunked.

Embedding(String)

Embedding generation or retrieval error.

Occurs during vector embedding operations.

Indexing(String)

Indexing operation error.

Occurs during document indexing or index updates.

Retrieval(String)

Retrieval operation error.

Occurs during document or chunk retrieval.

Storage(String)

Storage operation error.

Occurs during database or file storage operations.

Config(String)

Configuration error.

Invalid or missing configuration values.

Network(String)

Network/HTTP error.

Occurs during API calls, downloads, or network operations.

Daemon(String)

MCP Daemon error.

Occurs during daemon lifecycle management (start, stop, IPC).

Validation(String)

Schema validation error.

Input data does not conform to expected schema.

NotFound

Generic resource not found error.

Use this when a resource type is dynamic or not covered by specific variants.

Example

use reasonkit::Error;

let err = Error::NotFound { resource: "protocol:gigathink".to_string() };
assert!(err.to_string().contains("gigathink"));

Fields

resource: String

Resource identifier that was not found

IoMessage

I/O error with custom message.

Use when you need to provide additional context beyond what the standard I/O error contains.

Fields

message: String

Descriptive error message

Parse

Parse error with custom message.

Use for parsing failures that aren’t JSON-specific.

Fields

message: String

Descriptive error message

Qdrant(String)

Qdrant vector database error.

Occurs during Qdrant operations.

Tantivy(String)

Tantivy search engine error.

Occurs during Tantivy indexing or search operations.

ConfigError(String)

Config library parsing error.

Occurs when configuration files cannot be parsed.

WithContext

Generic error with context chain.

Use Error::with_context() to create this variant.

Example

use reasonkit::Error;

let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "file missing");
let err = Error::with_context("Loading configuration file", io_err);
assert!(err.to_string().contains("Loading configuration"));

Fields

context: String

Description of what operation was being attempted

source: Box<dyn Error + Send + Sync>

The underlying error

Mcp(String)

MCP (Model Context Protocol) error.

Occurs during MCP server/client operations.

M2ExecutionError(String)

M2 API execution error.

Occurs during MiniMax M2 model API calls.

RateLimitExceeded

M2 rate limit exceeded.

The API rate limit has been exceeded. Retry after waiting.

BudgetExceeded(f64, f64)

M2 budget exceeded.

The configured budget limit has been reached. Contains (actual_cost, budget_limit).

M2ProtocolValidation(String)

M2 protocol validation error.

The protocol definition or output failed validation.

M2ConstraintViolation(String)

M2 constraint violation.

A protocol constraint was not satisfied.

M2FrameworkIncompatibility(String)

M2 framework incompatibility.

The requested operation is not compatible with the current framework.

ResourceExhausted(String)

Resource exhausted (memory, connections, etc.).

A system resource has been exhausted.

TemplateNotFound(String)

Template not found.

The requested protocol or profile template does not exist.

CodeIntelligence(String)

Code intelligence error.

Occurs during code parsing or analysis.

M2IntegrationError(String)

M2 integration error.

General M2 integration failure.

Timeout(String)

Timeout error.

An operation exceeded its time limit.

DependencyNotMet(String)

Dependency not met.

A required dependency (step, component, etc.) was not satisfied.

ProtocolGenerationError(String)

Protocol generation error.

Failed to generate a protocol definition.

ThinkToolExecutionError(String)

ThinkTool execution error.

A ThinkTool failed during execution.

RateLimit(String)

Rate limit error.

API rate limiting was triggered.

Authentication(String)

Authentication error.

Authentication failed (invalid or missing credentials).

Authorization(String)

Authorization error.

The authenticated user lacks permission for the operation.

Implementations

impl Error

pub fn io(msg: impl Into<String>) -> Self

Create an I/O error from a message.

Arguments

• msg - Descriptive error message

Example

use reasonkit::Error;

let err = Error::io("Failed to open file");
assert!(err.to_string().contains("Failed to open"));

pub fn parse(msg: impl Into<String>) -> Self

Create a parse error from a message.

Arguments

• msg - Descriptive error message

Example

use reasonkit::Error;

let err = Error::parse("Invalid JSON syntax at line 42");

pub fn pdf(msg: impl Into<String>) -> Self

Create a PDF processing error from a message.

Arguments

• msg - Descriptive error message

pub fn embedding(msg: impl Into<String>) -> Self

Create an embedding error from a message.

Arguments

• msg - Descriptive error message

pub fn indexing(msg: impl Into<String>) -> Self

Create an indexing error from a message.

Arguments

• msg - Descriptive error message

pub fn retrieval(msg: impl Into<String>) -> Self

Create a retrieval error from a message.

Arguments

• msg - Descriptive error message

pub fn query(msg: impl Into<String>) -> Self

Create a query error from a message.

This is an alias for retrieval().

Arguments

• msg - Descriptive error message

pub fn storage(msg: impl Into<String>) -> Self

Create a storage error from a message.

Arguments

• msg - Descriptive error message

pub fn config(msg: impl Into<String>) -> Self

Create a config error from a message.

Arguments

• msg - Descriptive error message

pub fn network(msg: impl Into<String>) -> Self

Create a network error from a message.

Arguments

• msg - Descriptive error message

pub fn daemon(msg: impl Into<String>) -> Self

Create a daemon error from a message.

Arguments

• msg - Descriptive error message

pub fn validation(msg: impl Into<String>) -> Self

Create a validation error from a message.

Arguments

• msg - Descriptive error message

Example

use reasonkit::Error;

let err = Error::validation("Input must not be empty");

pub fn with_context<E>(context: impl Into<String>, source: E) -> Self

where E: Error + Send + Sync + 'static,

Wrap an error with additional context.

This creates an error chain, preserving the original error while adding context about what operation was being attempted.

Arguments

• context - Description of the operation that failed
• source - The underlying error

Example

use reasonkit::Error;

fn load_config(path: &str) -> Result<(), Error> {
    std::fs::read_to_string(path)
        .map_err(|e| Error::with_context(
            format!("Loading config from {}", path),
            e
        ))?;
    Ok(())
}

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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 Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

Convert reqwest errors to our Error type.

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<GigaThinkError> for Error

fn from(err: GigaThinkError) -> Self

Converts to this type from the input type.