Struct SessionState 

pub struct SessionState {

    pub provider: String,
    pub title: String,
    pub status: u32,
    pub activity: Option<String>,
    pub project: Option<ProjectInfo>,
    pub working_directory: Option<Uri>,
    pub annotations: Option<AnnotationsSummary>,
    pub lifecycle: SessionLifecycle,
    pub creation_error: Option<ErrorInfo>,
    pub server_tools: Option<Vec<ToolDefinition>>,
    pub active_clients: Vec<SessionActiveClient>,
    pub chats: Vec<ChatSummary>,
    pub default_chat: Option<Uri>,
    pub config: Option<SessionConfigState>,
    pub customizations: Option<Vec<Customization>>,
    pub changesets: Option<Vec<Changeset>>,
    pub input_needed: Option<Vec<SessionInputRequest>>,
    pub meta: Option<JsonObject>,
}

Full state for a single session, loaded when a client subscribes to the session’s URI.

Inlines (denormalizes) every {@link SessionMetadata} field directly onto itself so subscribers receive one flat object instead of a nested summary. The lightweight catalog representation is {@link SessionSummary}, surfaced on the root channel; the host keeps the two in sync via root/sessionSummaryChanged.

Fields

provider: String

Agent provider ID

title: String

Session title

status: u32

Current session status

activity: Option<String>

Human-readable description of what the session is currently doing

project: Option<ProjectInfo>

Server-owned project for this session

working_directory: Option<Uri>

The default working directory URI for this session. Individual chats MAY override via {@link ChatSummary.workingDirectory | their own workingDirectory}; this field acts as the fallback for any chat that does not.

annotations: Option<AnnotationsSummary>

Lightweight summary of this session’s inline annotations channel (ahp-session:/<uuid>/annotations). Surfaced so badge UI can render annotation / entry counts without subscribing. Absent when the session does not expose an annotations channel.

lifecycle: SessionLifecycle

Session initialization state

creation_error: Option<ErrorInfo>

Error details if creation failed

server_tools: Option<Vec<ToolDefinition>>

Tools provided by the server (agent host) for this session

active_clients: Vec<SessionActiveClient>

The clients currently providing tools and interactive capabilities to this session. If multiple tools or customizations are provided by the same active client, an agent host MAY deduplicate them when exposed to a model, with a preference given to the client that started the turn.

Membership is host-managed: clients add (or refresh) themselves with session/activeClientSet, and the host removes them with session/activeClientRemoved when they unsubscribe, disconnect without reconnecting in time, or reconnect without resubscribing to the session.

chats: Vec<ChatSummary>

Catalog of chats in this session.

default_chat: Option<Uri>

The chat that receives input when the user addresses the session without selecting a specific chat. This is a UI routing hint, not a hierarchy marker — chats remain equal peers at the protocol level. Hosts MAY change this over the session’s lifetime.

config: Option<SessionConfigState>

Session configuration schema and current values

customizations: Option<Vec<Customization>>

Top-level customizations active in this session.

Always one of the {@link Customization} variants:

• Container customizations ({@link PluginCustomization}, {@link DirectoryCustomization}) whose children — agents, skills, prompts, rules, hooks, MCP servers — live in each container’s {@link ContainerCustomizationBase.children | children} array.
• Top-level {@link McpServerCustomization} entries the host surfaces directly (for example a globally-configured MCP server that isn’t bundled in a plugin or directory). MCP servers may also appear as children of a container.

Client-published plugins arrive via {@link SessionActiveClient.customizations | activeClients[].customizations} and the host propagates them into this list (typically with the container’s clientId set and children populated). Clients publish in container shape only; bare MCP servers at the top level are server-originated.

changesets: Option<Vec<Changeset>>

Catalogue of changesets the server can produce for this session. Each entry advertises a subscribable view of file changes (uncommitted, session-wide, per-turn, etc.) and the URI template the client expands before subscribing. See {@link Changeset} for the full shape and {@link /guide/changesets | Changesets} for an overview of the model.

input_needed: Option<Vec<SessionInputRequest>>

Outstanding input the session is blocked on, aggregated across every chat so a client can discover and answer it from the session channel alone, without subscribing to individual chats.

Each entry is self-sufficient: it carries the owning chat’s URI plus every identifier the client needs to respond. A client answers by dispatching the ordinary chat/* action to that chat’s channel — see {@link SessionInputRequest} for the per-variant response path. A present, non-empty list implies {@link SessionStatus.InputNeeded} on {@link SessionSummary.status}.

Host-managed: the host upserts entries with session/inputNeededSet as chats raise requests and removes them with session/inputNeededRemoved once the underlying request resolves.

meta: Option<JsonObject>

Additional provider-specific metadata for this session.

Clients MAY look for well-known keys here to provide enhanced UI. For example, a git key may provide extra git metadata about the session’s workingDirectory.

Trait Implementations

impl Clone for SessionState

fn clone(&self) -> SessionState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SessionState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SessionState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SessionState

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SessionState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SessionState