Struct Responder 

pub struct Responder<T: JsonRpcResponse = Value> { /* private fields */ }

The context to respond to an incoming request.

This context is provided to request handlers and serves a dual role:

1. Respond to the request - Use respond or respond_with_result to send the response
2. Send other messages - Use the ConnectionTo parameter passed to your handler, which provides send_request, send_notification, and spawn

Example

connection.on_receive_request(async |req: ProcessRequest, responder, cx| {
    // Send a notification while processing
    cx.send_notification(StatusUpdate {
        message: "processing".into(),
    })?;

    // Do some work...
    let result = process(&req.data)?;

    // Respond to the request
    responder.respond(ProcessResponse { result })
}, agent_client_protocol::on_receive_request!())

Event Loop Considerations

Like all handlers, request handlers run on the event loop. Use spawn for expensive operations to avoid blocking the connection.

See the Event Loop and Concurrency section for more details.

Implementations

impl Responder<Value>

pub fn cast<T: JsonRpcResponse>(self) -> Responder<T>

Cast this request context to a different response type.

The provided type T will be serialized to JSON before sending.

impl<T: JsonRpcResponse> Responder<T>

pub fn method(&self) -> &str

Method of the incoming request

pub fn id(&self) -> Value

ID of the incoming request/response as a JSON value

pub fn erase_to_json(self) -> Responder<Value>

Convert to a Responder that expects a JSON value and which checks (dynamically) that the JSON value it receives can be converted to T.

pub fn wrap_method(self, method: String) -> Responder<T>

Return a new Responder with a different method name.

pub fn wrap_params<U: JsonRpcResponse>( self, wrap_fn: impl FnOnce(&str, Result<U, Error>) -> Result<T, Error> + Send + 'static, ) -> Responder<U>

Return a new Responder that expects a response of type U.

wrap_fn will be invoked with the method name and the result to transform type U into type T before sending.

pub fn respond_with_result( self, response: Result<T, Error>, ) -> Result<(), Error>

Respond to the JSON-RPC request with either a value (Ok) or an error (Err).

pub fn respond(self, response: T) -> Result<(), Error>

Respond to the JSON-RPC request with a value.

pub fn respond_with_internal_error( self, message: impl ToString, ) -> Result<(), Error>

Respond to the JSON-RPC request with an internal error containing a message.

pub fn respond_with_error(self, error: Error) -> Result<(), Error>

Respond to the JSON-RPC request with an error.

Trait Implementations

impl<T: JsonRpcResponse> Debug for Responder<T>

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

Formats the value using the given formatter.