Struct V2ResumeSessionBuilder 

pub struct V2ResumeSessionBuilder<Counterpart, Run = NullRun>
where
    Counterpart: HasPeer<Agent>,
    Run: RunWithConnectionTo<Counterpart>,
{ /* private fields */ }

Available on crate feature unstable_protocol_v2 only.

Builder for a draft protocol v2 session/resume request.

Replay updates arrive before the resume response. Direct clients must register typed v2::UpdateSessionNotification and interactive request handlers on crate::Builder before connecting. Proxies should use Self::on_proxy_session_start, which makes downstream session routing ready before publishing the resume request.

With both the unstable_protocol_v2 and unstable_mcp_over_acp features, with_mcp_server attaches an MCP server to the resumed session and makes it ready before the agent can send replay or its response.

Implementations

impl<Counterpart, Run> V2ResumeSessionBuilder<Counterpart, Run>

where Counterpart: HasPeer<Agent>, Run: RunWithConnectionTo<Counterpart>,

pub fn with_mcp_server<McpRun>( self, mcp_server: McpServer<Counterpart, McpRun>, ) -> Result<V2ResumeSessionBuilder<Counterpart, ChainRun<Run, McpRun>>, Error>

where McpRun: RunWithConnectionTo<Counterpart>,

Available on crate feature unstable_mcp_over_acp only.

Attach an MCP server to this resumed protocol v2 session.

This method is available when both unstable_protocol_v2 and unstable_mcp_over_acp are enabled. MCP routes are installed and their runner tasks receive an initial poll before session/resume is published, allowing the agent to use the server during replay and session setup. A successful attachment remains active for the lifetime of the connection.

pub fn start_session( self, ) -> SentRequest<OpenedV2Session<Counterpart, ResumeSessionResponse>>

where Run: 'static,

Send session/resume and return its independently consumable request.

The successful result contains both a cloneable command handle and the complete v2::ResumeSessionResponse. Consume the returned request with SentRequest::block_task, SentRequest::on_receiving_result, or another explicit SentRequest completion mode.

Replay is delivered through the typed connection handlers before the response. Attached MCP routes and runner tasks are ready before the request is published. A valid success response promotes them to the connection lifetime independently from how this request handle is consumed; setup errors clean up the pending attachment.

pub fn on_proxy_session_start<F, Fut>( self, responder: Responder<ResumeSessionResponse>, op: F, ) -> Result<(), Error>

where Counterpart: HasPeer<Client>, Run: 'static, F: FnOnce(OpenedV2Session<Counterpart, ResumeSessionResponse>) -> Fut + Send + 'static, Fut: Future<Output = Result<(), Error>> + Send,

Resume a protocol v2 session through a proxy and forward its response.

The session ID is known before the request, so this helper installs and acknowledges downstream session routing before publishing the ordered session/resume request. Replay can therefore be forwarded before the response as required by the protocol. The downstream request inherits cancellation from the upstream request.

On success, the helper forwards the complete response and spawns op with an OpenedV2Session containing the command-only session handle plus that response. The callback runs outside the ordered response barrier, so it may wait for later connection traffic without deadlocking the dispatch loop.

Trait Implementations

impl<Counterpart, Run> Debug for V2ResumeSessionBuilder<Counterpart, Run>

where Counterpart: HasPeer<Agent> + Debug, Run: RunWithConnectionTo<Counterpart> + Debug,

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

Formats the value using the given formatter.