Struct TransportWireClient 

pub struct TransportWireClient<T: Transport> { /* private fields */ }

A WireClient implementation backed by any Transport.

Implementations

impl<T: Transport> TransportWireClient<T>

pub const fn new(transport: T) -> Self

Create a new client wrapping the given transport.

pub fn into_transport(self) -> T

Consume the client and return the underlying transport.

pub const fn with_default_timeout(self, timeout: Duration) -> Self

Set a default timeout applied to every read_response call. Without this, read_response waits indefinitely for a matching id.

pub const fn with_max_io_retries(self, retries: u32) -> Self

Set the maximum number of retries for transient I/O errors during read_response. Each retry waits exponentially longer (50ms * 2^attempt).

Trait Implementations

impl<T: Transport> Debug for TransportWireClient<T>

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

Formats the value using the given formatter.

impl<T: Transport> WireClient for TransportWireClient<T>

fn next_id(&mut self) -> String

Generate the next request id.

async fn send_request<Params: Serialize + Sync>( &mut self, req: &JsonRpcRequest<Params>, ) -> Result<(), WireError>

Send a JSON-RPC request.

async fn read_raw_message(&mut self) -> Result<RawWireMessage, WireError>

Read the next incoming raw wire message.

async fn read_raw_message_timeout( &mut self, timeout: Duration, ) -> Result<RawWireMessage, WireError>

Read the next incoming raw wire message with a timeout.

async fn read_response<Res: DeserializeOwned + Send>( &mut self, expected_id: &str, ) -> Result<Res, WireError>

Wait for a response matching expected_id, buffering out-of-order messages internally.

async fn send_response<Res: Serialize + Send>( &mut self, id: &str, result: Res, ) -> Result<(), WireError>

Send a JSON-RPC success response.

async fn send_error( &mut self, id: &str, code: i32, message: &str, ) -> Result<(), WireError>

Send a JSON-RPC error response.

async fn initialize( &mut self, params: InitializeParams, ) -> Result<InitializeResult, WireError>

Perform the initialize handshake.

fn is_handshake_done(&self) -> bool

Returns true if the initialize handshake has completed.

async fn shutdown(self) -> Result<(), WireError>

Gracefully shut down the client.

fn prompt( &mut self, user_input: impl Into<UserInput> + Send, ) -> impl Future<Output = Result<PromptResult, WireError>> + Send

Send a prompt and wait for the result.

fn start_prompt( &mut self, user_input: impl Into<UserInput> + Send, ) -> impl Future<Output = Result<String, WireError>> + Send

Send a prompt without waiting for the result.

fn replay( &mut self, ) -> impl Future<Output = Result<ReplayResult, WireError>> + Send

Replay events and requests from the current session.

fn steer( &mut self, user_input: impl Into<UserInput> + Send, ) -> impl Future<Output = Result<SteerResult, WireError>> + Send

Steer the current turn with additional user input.

fn set_plan_mode( &mut self, enabled: bool, ) -> impl Future<Output = Result<SetPlanModeResult, WireError>> + Send

Enable or disable plan mode.

fn cancel(&mut self) -> impl Future<Output = Result<(), WireError>> + Send

Cancel the current turn.