Struct PooledAgent 

pub struct PooledAgent {
    pub ws_to_agent_tx: Sender<String>,
    pub agent_to_ws_tx: Sender<String>,
    pub connected: bool,
    pub disconnected_at: Option<Instant>,
    pub message_buffer: Vec<String>,
    pub cached_init_response: Option<String>,
    pub cached_session_response: Option<String>,
    pub agent_command: String,
    /* private fields */
}

A pooled agent process with its I/O handles

Fields

ws_to_agent_tx: Sender<String>

Sender for messages going to the agent (from WebSocket to stdin)

agent_to_ws_tx: Sender<String>

Broadcast sender for messages from agent stdout. Each new connection subscribes via .subscribe()

connected: bool

Whether a client is currently connected

disconnected_at: Option<Instant>

When the client last disconnected (for idle timeout)

message_buffer: Vec<String>

Buffered messages from agent while client was disconnected

cached_init_response: Option<String>

Cached initialize response from the agent (raw JSON-RPC result). On reconnect we intercept the client’s initialize request and reply with this cached response instead of forwarding to the agent.

cached_session_response: Option<String>

Cached createSession response from the agent (raw JSON-RPC result). On reconnect we intercept the client’s createSession request and reply with this cached response, preserving the same session ID so the agent keeps its conversation history.

agent_command: String

The agent command used to spawn this agent

Implementations

impl PooledAgent

pub fn is_alive(&mut self) -> bool

Check if this agent’s process is still running

pub async fn kill(&mut self)

Kill the agent process gracefully

pub fn subscribe(&self) -> Receiver<String>

Subscribe to agent stdout messages