Struct CurrentBackend 

pub struct CurrentBackend {
    pub id: String,
    pub name: String,
    pub version: String,
    pub title: Option<String>,
    pub client: ClientIdentity,
}

Identity of the backend currently connected to this process, captured at the ACP initialize handshake.

Stored process-globally so any code path — not only the adapter itself — can answer “which backend am I talking to?”. The agent primitive resolves its default backend (when the script omits backend) from this store via the id field, rather than each caller threading an explicit backend argument through every call.

Semantics: written by the ACP adapter on every handshake. In the current single-backend model the value is constant for a run’s lifetime. With multiple backends it becomes “most recently handshaken”, so readers must tolerate concurrent writers; the scheduler falls back to the registry’s designated default when the captured id is stale or missing.

Fields

id: String

Registry key of this backend (i.e. AgentBackend::id, e.g. "opencode", "codex"). This is the value the scheduler uses to route a default (backend-omitted) agent, and it is set from the adapter’s own config.id — so it is guaranteed to match a registry key, unlike the ACP-reported name.

name: String

Backend implementation name as reported by the ACP peer, e.g. “opencode”, “codex”. Display/metadata only — not used for routing.

version: String

Backend implementation version.

title: Option<String>

Optional human-readable title.

client: ClientIdentity

Client identity sent by Luft during the ACP initialize handshake.

Trait Implementations

impl Clone for CurrentBackend

fn clone(&self) -> CurrentBackend

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CurrentBackend

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

Formats the value using the given formatter.

impl Eq for CurrentBackend

impl PartialEq for CurrentBackend

fn eq(&self, other: &CurrentBackend) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for CurrentBackend