Struct AgentChannel 

pub struct AgentChannel { /* private fields */ }

Communication channel with the remote agent

Implementations

impl AgentChannel

pub fn new(reader: BufReader<ChildStdout>, writer: ChildStdin) -> Self

Create a new channel from async read/write handles

Must be called from within a Tokio runtime context.

pub fn with_capacity( reader: BufReader<ChildStdout>, writer: ChildStdin, data_channel_capacity: usize, ) -> Self

Create a new channel with a custom data channel capacity.

Lower capacity makes channel overflow more likely if try_send is used, which is useful for stress-testing backpressure handling.

pub fn from_transport<R, W>( reader: R, writer: W, data_channel_capacity: usize, ) -> Self

where R: AsyncBufRead + Unpin + Send + 'static, W: AsyncWrite + Unpin + Send + 'static,

Create a new channel from any async reader/writer pair.

This is the generic constructor used by both production code (via new/with_capacity) and tests (via arbitrary AsyncBufRead/AsyncWrite implementations like DuplexStream).

Must be called from within a Tokio runtime context.

pub fn is_connected(&self) -> bool

Check if the channel is connected

pub async fn replace_transport<R, W>(&self, reader: R, writer: W)

where R: AsyncBufRead + Unpin + Send + 'static, W: AsyncWrite + Unpin + Send + 'static,

Replace the underlying transport with a new reader/writer pair.

This is used for reconnection: after establishing a new SSH connection, call this method to feed the new stdin/stdout to the existing read/write tasks. The tasks will resume processing and is_connected() will return true once the first successful read/write completes.

The connected flag is set to true by the read task after it has received the new reader and drained stale pending requests. This ensures no race between draining and new request submission.

pub fn replace_transport_blocking<R, W>(&self, reader: R, writer: W)

where R: AsyncBufRead + Unpin + Send + 'static, W: AsyncWrite + Unpin + Send + 'static,

Replace the underlying transport (blocking version for non-async contexts).

Sends the new transport to the tasks and waits until the channel is marked as connected (i.e., the read task has drained stale requests and is ready to receive responses on the new reader).

pub fn set_request_timeout(&self, timeout: Duration)

Set the request timeout duration.

Requests that don’t receive a response within this duration will fail with ChannelError::Timeout and the connection will be marked as disconnected.

pub async fn request( &self, method: &str, params: Value, ) -> Result<Value, ChannelError>

Send a request and wait for the final result (ignoring streaming data)

pub async fn request_streaming( &self, method: &str, params: Value, ) -> Result<(Receiver<Value>, Receiver<Result<Value, String>>), ChannelError>

Send a request that may stream data

pub fn request_blocking( &self, method: &str, params: Value, ) -> Result<Value, ChannelError>

Send a request synchronously (blocking)

This can be called from outside the Tokio runtime context.

pub async fn request_with_data( &self, method: &str, params: Value, ) -> Result<(Vec<Value>, Value), ChannelError>

Send a request and collect all streaming data along with the final result

pub fn request_with_data_blocking( &self, method: &str, params: Value, ) -> Result<(Vec<Value>, Value), ChannelError>

Send a request with streaming data, synchronously (blocking)

This can be called from outside the Tokio runtime context.

pub async fn cancel(&self, request_id: u64) -> Result<(), ChannelError>

Cancel a request