Struct ConnectionInner 

pub struct ConnectionInner {

    pub http_client: Client,
    pub url: String,
    pub session_id: String,
    pub headers: IndexMap<String, String>,
    pub extra_headers: RwLock<IndexMap<String, String>>,
    pub backoff_current_interval: Duration,
    pub backoff_initial_interval: Duration,
    pub backoff_randomization_factor: f64,
    pub backoff_multiplier: f64,
    pub backoff_max_interval: Duration,
    pub backoff_max_elapsed_time: Duration,
    pub call_timeout: Duration,
    pub initialize_result: InitializeResult,
    /* private fields */
}

The actual connection state. Behind an Arc inside Connection.

Fields are public for read-only access (callers reach them via Connection’s Deref), but every method on this type is private — the public surface lives on Connection and delegates through.

Fields

http_client: Client

url: String

session_id: String

headers: IndexMap<String, String>

All HTTP headers stamped on every POST / GET this connection makes — the same merged map (defaults + caller overrides) the Client built once during connect. Mcp-Session-Id, Content-Type, and Accept are still set by the request builders and override anything in headers.

extra_headers: RwLock<IndexMap<String, String>>

Mutable per-request override layer stamped AFTER headers on every outbound HTTP request. The request-builder uses reqwest::header::HeaderMap::insert semantics so any key present in extra_headers REPLACES the same key in headers. Used by the proxy to inject session-global headers (X-OBJECTIVEAI-RESPONSE-ID etc.) that override per-URL values without re-dialing. Empty by default; set via Connection::set_extra_headers.

backoff_current_interval: Duration

backoff_initial_interval: Duration

backoff_randomization_factor: f64

backoff_multiplier: f64

backoff_max_interval: Duration

backoff_max_elapsed_time: Duration

call_timeout: Duration

initialize_result: InitializeResult

The server’s capabilities and info from the initialize response.

Trait Implementations

impl Debug for ConnectionInner

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

Formats the value using the given formatter.

impl Drop for ConnectionInner

fn drop(&mut self)

Orphan-DELETE hook: when a freshly-minted connection (not a resume) is dropped without any deliberate use — no call_tool, no read_resource, no explicit Connection::delete — spawn a fire-and-forget HTTP DELETE so the upstream session we just opened doesn’t sit there accruing per-session state for nothing.

Reconnect-resumes are deliberately excluded: a reconnect’s any_calls == false only means this Connection instance never called anything — the underlying upstream session may well have been used by an earlier Connection that opened it, did real work, and let us re-attach. Tearing it down here would kill a still-live session out from under whoever owns it. Reconnects rely on the proxy’s explicit Connection::delete (or Client::delete) for upstream cleanup instead.

Skip conditions (any one triggers a no-op):

• mock is true — there was never an HTTP session to begin with.
• is_reconnect is true — see above; the upstream session pre-existed this connection and isn’t ours to tear down on drop.
• any_calls is true — the connection was deliberately used, or an explicit Connection::delete already ran.
• No tokio runtime is in scope — tokio::spawn would panic. Silently leak the upstream session in this case (sync teardown paths e.g. cfg(test) blocks not driven by tokio).

The listener-cancel DropGuard inside _listener_cancel_guard fires automatically as part of this same drop call, so by the time the orphan DELETE goes out the listener task has already been told to cancel — no SSE/GET race with the upstream DELETE.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.