Struct CapabilityManifest 

pub struct CapabilityManifest {
    pub version: u16,
    pub tools: [u64; 128],
    pub resources: [u64; 16],
    pub prompts: [u64; 8],
    pub extensions: u64,
    pub signature: [u8; 64],
    /* private fields */
}

Pre-computed capability manifest

Uses bitsets for efficient capability representation and intersection.

• tools: 8192 bits (128 × u64) = supports up to 8192 tools
• resources: 1024 bits (16 × u64) = supports up to 1024 resources
• prompts: 512 bits (8 × u64) = supports up to 512 prompts

Fields

version: u16

Protocol version

tools: [u64; 128]

Supported tools bitset (8192 bits = 1024 bytes)

resources: [u64; 16]

Supported resources bitset (1024 bits = 128 bytes)

prompts: [u64; 8]

Supported prompts bitset (512 bits = 64 bytes)

extensions: u64

Extension flags

signature: [u8; 64]

Ed25519 signature

Implementations

impl CapabilityManifest

pub const SIZE: usize

Size of the manifest in bytes

pub const MAX_TOOLS: usize = 8192

Maximum number of tools supported

pub const MAX_RESOURCES: usize = 1024

Maximum number of resources supported

pub const MAX_PROMPTS: usize = 512

Maximum number of prompts supported

pub fn new(version: u16) -> CapabilityManifest

Create a new empty capability manifest

pub fn from_bytes(bytes: &[u8]) -> Result<&CapabilityManifest, DCPError>

Parse manifest from bytes

pub fn as_bytes(&self) -> &[u8]

Serialize manifest to bytes

pub fn signed_bytes(&self) -> &[u8]

Get the bytes that are signed (everything before the signature)

pub fn intersect(&self, other: &CapabilityManifest) -> CapabilityManifest

Compute capability intersection - single CPU instruction per word

Returns a new manifest containing only capabilities present in both manifests.

pub fn negotiate( client: &CapabilityManifest, server: &CapabilityManifest, ) -> CapabilityManifest

Negotiate a deny-by-default manifest from client and server offers.

pub fn require_tool(&self, tool_id: u16) -> Result<(), SecurityError>

Require that a negotiated tool capability is present.

pub fn require_resource(&self, resource_id: u16) -> Result<(), SecurityError>

Require that a negotiated resource capability is present.

pub fn require_prompt(&self, prompt_id: u16) -> Result<(), SecurityError>

Require that a negotiated prompt capability is present.

pub fn require_extension(&self, bit: u8) -> Result<(), SecurityError>

Require that a negotiated extension capability is present.

pub fn set_tool(&mut self, tool_id: u16)

Set a tool capability

pub fn clear_tool(&mut self, tool_id: u16)

Clear a tool capability

pub fn has_tool(&self, tool_id: u16) -> bool

Check if a tool is supported

pub fn set_resource(&mut self, resource_id: u16)

Set a resource capability

pub fn clear_resource(&mut self, resource_id: u16)

Clear a resource capability

pub fn has_resource(&self, resource_id: u16) -> bool

Check if a resource is supported

pub fn set_prompt(&mut self, prompt_id: u16)

Set a prompt capability

pub fn clear_prompt(&mut self, prompt_id: u16)

Clear a prompt capability

pub fn has_prompt(&self, prompt_id: u16) -> bool

Check if a prompt is supported

pub fn set_extension(&mut self, bit: u8)

Set an extension flag

pub fn clear_extension(&mut self, bit: u8)

Clear an extension flag

pub fn has_extension(&self, bit: u8) -> bool

Check if an extension is supported

pub fn tool_count(&self) -> u32

Count the number of supported tools

pub fn resource_count(&self) -> u32

Count the number of supported resources

pub fn prompt_count(&self) -> u32

Count the number of supported prompts

pub fn extension_count(&self) -> u32

Count the number of enabled extensions

pub fn tool_ids(&self) -> impl Iterator<Item = u16>

Get an iterator over all supported tool IDs

pub fn resource_ids(&self) -> impl Iterator<Item = u16>

Get an iterator over all supported resource IDs

pub fn prompt_ids(&self) -> impl Iterator<Item = u16>

Get an iterator over all supported prompt IDs

Trait Implementations

impl Clone for CapabilityManifest

fn clone(&self) -> CapabilityManifest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CapabilityManifest

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

Formats the value using the given formatter.

impl Default for CapabilityManifest

fn default() -> CapabilityManifest

Returns the “default value” for a type.

impl Eq for CapabilityManifest

impl PartialEq for CapabilityManifest

fn eq(&self, other: &CapabilityManifest) -> 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 StructuralPartialEq for CapabilityManifest