Struct Capabilities 

pub struct Capabilities {

    pub schema_version: String,
    pub tier: String,
    pub version: String,
    pub features: CapabilityFeatures,
    pub models: CapabilityModels,
    pub permissions: CapabilityPermissions,
    pub hooks: CapabilityHooks,
    pub compaction: CapabilityCompaction,
    pub approval: CapabilityApproval,
    pub transcripts: CapabilityTranscripts,
    pub hnsw: CapabilityHnsw,
    pub kg_backend: Option<String>,
    pub memory_kinds: Vec<String>,
}

Top-level capabilities report for a running instance.

Schema versions:

• v1 (legacy, pre-v0.6.3.1): tier, version, features, models. Reachable via Accept-Capabilities: v1 (HTTP) or the MCP accept argument set to "v1". See CapabilitiesV1.
• v2 (v0.6.3.1 honesty patch): schema_version="2" plus the permissions, hooks, compaction, approval, transcripts blocks. v1 fields preserved at the same top-level paths — old clients that read v2 by name continue to work for the un-dropped fields. Default response shape.

v2 honesty patch (P1, v0.6.3.1):

• features.recall_mode_active and features.reranker_active are runtime state, not config-derived flags.
• features.memory_reflection is now a {planned, version, enabled} object, not a bool.
• compaction and transcripts carry the same planned-feature shape so operators can distinguish “disabled but built” from “not in this build.”
• permissions.mode = "advisory" until the enforcement gate ships in P4. Was "ask", which implied an active interactive loop.
• The following fields were removed because no backing implementation exists: permissions.rule_summary, hooks.by_event, approval.subscribers, approval.default_timeout_seconds.

Fields

schema_version: String

Schema-version discriminator. Always "2" since v0.6.3.

tier: String

version: String

features: CapabilityFeatures

models: CapabilityModels

permissions: CapabilityPermissions

Active permission/governance rules. Pre-P4 reports the count of namespaces that have a metadata.governance policy attached to their standard memory; the underlying permission system itself is P4 work.

hooks: CapabilityHooks

Registered hooks. Pre-v0.7 reports webhook subscriptions as a proxy (hook system itself is v0.7 Bucket 0).

compaction: CapabilityCompaction

Compaction state. v0.8 work — reports {planned, version, enabled} until the subsystem ships.

approval: CapabilityApproval

Approval API state. Reports the live count of pending actions from the existing pending_actions table.

transcripts: CapabilityTranscripts

Sidechain-transcript state. v0.7 Bucket 1.7 work — reports {planned, version, enabled} until the subsystem ships.

hnsw: CapabilityHnsw

v0.6.3.1 (P3, G2): HNSW vector-index health. Defaults to a quiet zero-state report; the MCP/HTTP capabilities wrapper overwrites with live process counters when the index module has run an eviction.

kg_backend: Option<String>

v0.7 J1 — knowledge-graph backend tag. "age" when a Postgres SAL adapter probed Apache AGE successfully at connect time; "cte" when the deployment falls back to the recursive-CTE path (every SQLite deployment + Postgres without AGE installed). None when no SAL adapter is wired (the active dispatch path through the legacy crate::db free functions pre-J2). Operators consult this through ai-memory doctor and memory_capabilities to verify which traversal path their daemon actually runs. Skipped from the JSON wire when None so v1 / v2 clients that don’t know the field round-trip cleanly.

memory_kinds: Vec<String>

L1-1 (v0.7.0) — the set of typed memory kinds this binary supports. Always ["observation", "reflection"] for v0.7.0; Goal/Plan/Step/Decision land in L1-6/v0.8.0. Callers that want to enumerate valid values for a memory_kind filter should consult this field rather than hardcoding the list.

#[serde(default)] keeps older capabilities consumers that don’t know the field from breaking.

Implementations

impl Capabilities

pub fn to_v1(&self) -> CapabilitiesV1

Project the v2 report down to the legacy v1 shape. Used to honour Accept-Capabilities: v1 from older clients.

memory_reflection collapses from {planned, enabled} to a single bool (enabled value). All v2-only fields (recall_mode_active, reranker_active, permissions, hooks, compaction, approval, transcripts) are dropped.

pub fn to_v3( &self, summary: String, to_describe_to_user: String, tools: Vec<ToolEntry>, agent_permitted_families: Option<Vec<String>>, your_harness_supports_deferred_registration: Option<bool>, ) -> CapabilitiesV3

v0.7.0 (A1+A2+A3+A4): project the report into the v3 shape.

v3 = v2 +

• top-level summary (A1) — terse description of operational access plus the three named recovery paths.
• top-level to_describe_to_user (A2) — plain-English end-user-facing sentence the LLM should repeat verbatim when asked “what tools do you have?”. No MCP jargon.
• top-level tools (A3) — per-tool array carrying name, family, loaded, and callable_now. callable_now combines profile-side loaded-state with the [mcp.allowlist] agent-can-call decision so an LLM that keeps a manifest cache doesn’t need to ask twice to know whether a tool will resolve.
• top-level agent_permitted_families (A4, optional) — when the [mcp.allowlist] is enabled AND an agent_id is provided, lists the family names the requesting agent is allowed to access (collapses every callable_now=true entry’s family to a unique list). When the allowlist is disabled or no agent_id is provided, the field is omitted from the wire (so v2-shaped consumers see no churn from A4 alone).

All four are computed by the caller from the live Profile + McpConfig + agent_id state because the Capabilities struct itself doesn’t know which families the MCP server actually advertised or which agent is asking.

A5 bumps the default wire shape to v3. v2 stays supported indefinitely.

Trait Implementations

impl Clone for Capabilities

fn clone(&self) -> Capabilities

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Capabilities

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Capabilities

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Capabilities

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

where __S: Serializer,

Serialize this value into the given Serde serializer.