Enum BidirError 

pub enum BidirError {
    NotSupported,
    Timeout(u64),
    Cancelled,
    TypeMismatch {
        expected: String,
        got: String,
    },
    Serialization(String),
    Transport(String),
    UnknownRequest,
    ChannelClosed,
}

Error types for bidirectional communication

This enum covers all failure modes that can occur during bidirectional request/response cycles. Activations should handle these errors gracefully, especially BidirError::NotSupported which indicates the transport cannot support interactive features.

Common Patterns

use plexus_core::plexus::bidirectional::{BidirError, StandardBidirChannel};

async fn my_method(ctx: &StandardBidirChannel) {
    match ctx.confirm("Proceed?").await {
        Ok(true) => { /* user confirmed */ }
        Ok(false) => { /* user declined */ }
        Err(BidirError::NotSupported) => {
            // Non-interactive transport - use safe defaults
        }
        Err(BidirError::Cancelled) => {
            // User explicitly cancelled
        }
        Err(BidirError::Timeout(_)) => {
            // User didn't respond in time
        }
        Err(e) => {
            // Other errors - log and handle
            eprintln!("Bidirectional error: {}", e);
        }
    }
}

Variants

NotSupported

Transport does not support bidirectional communication.

This is a normal condition - many transports (HTTP, some MCP configs) cannot support server-to-client requests. Activations should have fallback behavior when this error occurs.

Example

match ctx.confirm("Delete?").await {
    Err(BidirError::NotSupported) => {
        // Don't delete without confirmation
        return Err("Interactive confirmation required");
    }
    // ...
}

Timeout(u64)

Request timed out waiting for client response.

The timeout value (in milliseconds) is included. Default timeout is 30 seconds, configurable via request_with_timeout() method.

Example

match ctx.confirm("Confirm?").await {
    Err(BidirError::Timeout(ms)) => {
        println!("No response after {}ms", ms);
    }
    // ...
}

Cancelled

Client explicitly cancelled the request.

This indicates the user chose to cancel rather than respond. Different from declining - cancel means “abort the workflow”.

TypeMismatch

Response type doesn’t match expected type.

This usually indicates a bug in client code or a protocol mismatch. For example, responding with Text to a Confirm request.

Fields

expected: String

Expected type name

got: String

Actual type received

Serialization(String)

Failed to serialize or deserialize request/response.

Contains the underlying serialization error message.

Transport(String)

Transport-level error during communication.

This covers network errors, connection drops, etc.

UnknownRequest

Unknown request ID (response for non-existent request).

This can happen if:

• The request already timed out
• The request was cancelled
• The request ID was corrupted

ChannelClosed

Response channel was closed before response received.

This typically means the waiting task was cancelled or dropped.

Trait Implementations

impl Clone for BidirError

fn clone(&self) -> BidirError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BidirError

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

Formats the value using the given formatter.

impl Display for BidirError

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

Formats the value using the given formatter.

impl Error for BidirError

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.