Enum MCPError 

pub enum MCPError {
    Io {
        message: String,
    },
    Json {
        message: String,
    },
    Transport(String),
    TransportConnectionFailed {
        message: String,
    },
    TransportDisconnected,
    Protocol(String),
    InvalidRequest(String),
    MethodNotFound(String),
    InvalidParams {
        method: String,
        message: String,
    },
    InternalError(String),
    ConnectionClosed,
    Timeout {
        duration: Duration,
        request_id: String,
    },
    RequestNotFound(String),
    HandlerError {
        handler_type: String,
        message: String,
    },
    ResourceNotFound {
        uri: String,
    },
    ToolExecutionFailed {
        tool: String,
        message: String,
    },
    MessageTooLarge {
        size: usize,
        max_size: usize,
    },
    InvalidMessageFormat {
        message: String,
    },
    CodecError {
        message: String,
    },
}

Variants

Io

Fields

message: String

Json

Fields

message: String

Transport(String)

TransportConnectionFailed

Fields

message: String

TransportDisconnected

Protocol(String)

InvalidRequest(String)

MethodNotFound(String)

InvalidParams

Fields

method: String

message: String

InternalError(String)

ConnectionClosed

Timeout

Fields

duration: Duration

request_id: String

RequestNotFound(String)

HandlerError

Fields

handler_type: String

message: String

ResourceNotFound

Fields

uri: String

ToolExecutionFailed

Fields

tool: String

message: String

MessageTooLarge

Fields

size: usize

max_size: usize

InvalidMessageFormat

Fields

message: String

CodecError

Fields

message: String

Implementations

impl MCPError

pub fn invalid_params( method: impl Into<String>, message: impl Into<String>, ) -> Self

Create an InvalidParams error with method context

Examples found in repository

examples/error_handling.rs (line 72)

    async fn execute(&self, arguments: Option<serde_json::Value>) -> Result<Vec<Content>> {
        let args = arguments
            .ok_or_else(|| MCPError::invalid_params("strict_tool", "Missing arguments object"))?;

        let required_field = args
            .get("required_field")
            .and_then(|v| v.as_str())
            .ok_or_else(|| {
                MCPError::invalid_params(
                    "strict_tool",
                    "Missing or invalid 'required_field' parameter",
                )
            })?;

        Ok(vec![Content::Text(TextContent {
            text: format!("Received: {required_field}"),
            annotations: None,
        })])
    }

pub fn timeout(duration: Duration, request_id: impl Into<String>) -> Self

Create a Timeout error with duration and request context

pub fn handler_error( handler_type: impl Into<String>, message: impl Into<String>, ) -> Self

Create a HandlerError with type context

pub fn tool_execution_failed( tool: impl Into<String>, message: impl Into<String>, ) -> Self

Create a ToolExecutionFailed error

Examples found in repository

examples/error_handling.rs (lines 35-38)

    async fn execute(&self, _arguments: Option<serde_json::Value>) -> Result<Vec<Content>> {
        Err(MCPError::tool_execution_failed(
            "always_fail",
            "This tool always fails for testing purposes",
        ))
    }

pub fn is_retryable(&self) -> bool

Check if this error is retryable

Examples found in repository

examples/timeout_client.rs (line 88)

async fn test_broken_operation(client: &mut MCPClient) -> Result<()> {
    info!("\n=== Testing Broken Operation ===");
    info!("This operation always fails with a non-retryable error.");
    info!("Should fail immediately without retries...");

    match client.call_tool("broken_operation".to_string(), None).await {
        Ok(_) => {
            error!("✗ Unexpected success");
        }
        Err(e) => {
            info!("✓ Expected non-retryable error: {}", e);
            // Verify it's actually non-retryable
            if e.is_retryable() {
                error!("Error was retryable when it shouldn't be: {:?}", e);
            }
        }
    }

    Ok(())
}

Trait Implementations

impl Clone for MCPError

fn clone(&self) -> MCPError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MCPError

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

Formats the value using the given formatter.

impl Display for MCPError

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

Formats the value using the given formatter.

impl Error for MCPError

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 MCPError

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<Error> for MCPError

fn from(err: Error) -> Self

Converts to this type from the input type.