Struct ProtocolMetadataV2 

pub struct ProtocolMetadataV2 {
    pub state: DevelopmentState,
    pub privilege_requirement: PrivilegeRequirement,
    pub implementation: &'static str,
    pub llm_control: &'static str,
    pub e2e_testing: &'static str,
    pub notes: Option<&'static str>,
    pub connectionless: bool,
    pub failure_mode: FailureMode,
    pub max_inbound_bytes: Option<usize>,
    pub well_known_port: Option<u16>,
    pub well_known_transport: PortTransport,
    pub request_only: Option<&'static str>,
}

Enhanced protocol metadata with detailed implementation information

Fields

state: DevelopmentState

Current maturity/readiness state

privilege_requirement: PrivilegeRequirement

Privilege requirements for this protocol

implementation: &'static str

Freeform description of implementation approach Examples:

• “hyper v1.0 web server library”
• “russh v0.40 with SFTP support”
• “Manual NTP packet parser with 48-byte construction”
• “defguard_wireguard_rs v0.7 - creates real TUN interfaces”
• “Custom Tor OR protocol with ntor handshake - 2,182 LOC”

llm_control: &'static str

Freeform description of what the LLM controls Examples:

• “Full byte stream control”
• “Response content (status, headers, body)”
• “Authentication decisions + shell responses + SFTP operations”
• “Time responses (stratum, timestamps)”
• “Query responses (result sets, OK, errors)”
• “No LLM control - direct Ollama delegation”
• “Observation only - no LLM interaction”

e2e_testing: &'static str

Freeform description of E2E testing approach Examples:

• “reqwest HTTP client”
• “ssh2 crate (libssh2 bindings)”
• “OpenSSH ssh command”
• “Manual NTP packet construction”
• “tokio-postgres client”
• “Not yet implemented”
• “N/A (honeypot only)”

notes: Option<&'static str>

Optional notes about limitations or special features

connectionless: bool

The protocol has no connection lifecycle of its own: its “connections” are per-remote-address bookkeeping entries (UDP, raw IP, link-level) that nothing ever closes, so the runtime reaps them after last_activity goes stale.

Leave false for anything connection-oriented. The reaper used to run over every server, and an idle TCP-style connection — a telnet peer waiting ten seconds for a human’s manual answer — was evicted and shown as closed while its socket was perfectly alive.

failure_mode: FailureMode

What this server puts on the wire when the model cannot or will not answer.

Defaults to FailureMode::Answers, which is the right default: a protocol that has an error vocabulary and stays silent leaves its peer to wait out a timeout, and that is the failure the August 2026 sweep found in 64 of 135 servers. Declaring FailureMode::DeliberatelySilent is an assertion that every frame this protocol could send would be a claim it cannot support — say why in notes.

max_inbound_bytes: Option<usize>

The largest single inbound message this server will buffer from a peer, in bytes.

None means the protocol reads nothing whose length a peer chooses: a fixed-size frame (ARP, BOOTP), a single recv_from into a fixed buffer, or a profile that delegates its whole read loop to another protocol. None is a claim, not an absence — a protocol that does accumulate and declares None is the unbounded-read defect, and tests/max_inbound_bytes_declaration_test.rs is the ratchet that says so.

The number must be the one the code enforces, at the point the length is decided — not an aspiration. The value exists to be greppable and testable: every declaration should have a test that sends this many bytes plus one and asserts the refusal happens before any model call. A bound nobody tested is a comment.

Bound the size the peer declared, before doing arithmetic on it. NATS’s HPUB limit was applied to total − header, which leaves header unbounded and lets header == total pass every check with a zero-length body — thirty bytes on the wire buffering toward 4 GB.

well_known_port: Option<u16>

The port this protocol is registered for — IANA’s registry, or where IANA has none, the default its own specification or reference implementation documents (Elasticsearch 9200, hg serve 8000). Never a “developer” port like 8080 standing in for HTTP’s 80.

None is a claim, not an absence: the protocol has no port of its own — raw sockets, link layer, a device, a pipe, or an application protocol carried on plain HTTP whose port is HTTP’s. tests/well_known_port_declaration_test.rs requires every server to declare one or be listed there with the reason.

This is what a server starts on when the caller names no port, subject to crate::protocol::default_port::resolve_default_port: below 1024 it needs privilege, and a port already taken falls back to an OS-assigned one. An explicit port — 0 included — is never replaced.

well_known_transport: PortTransport

The transport used by this protocol’s port-based listener. Also applies when Self::well_known_port is None, such as raw UDP on an operator-chosen port. The builder’s default is TCP; socketless protocols do not use this field.

request_only: Option<&'static str>

Why this server can only ever answer a peer, when that is a property of the protocol itself: every message it may send is the reply to one the peer sent first (HTTP/1.1 and the protocols carried on plain HTTP request/response). None claims nothing.

It is what the dashboard says on a peer’s disabled [ send message ], and what the MCP send_to_peer error gives as the reason, instead of “not implemented here yet” — for these protocols there is no “yet”. A protocol that registers a peer handle (server/peer_support.rs) can message a peer unprompted, so it must not declare this; tests/request_only_declaration_test.rs holds that from source.

Write the reason as the sentence a person reads: “HTTP only answers requests; a server cannot send a peer anything unprompted”.

Implementations

impl ProtocolMetadataV2

pub const fn builder() -> ProtocolMetadataV2Builder

Create a new builder for protocol metadata

pub fn is_available_to_llm(&self) -> bool

Check if this protocol should be shown to the LLM

pub fn summary(&self) -> String

Get a human-readable summary

Trait Implementations

impl Clone for ProtocolMetadataV2

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProtocolMetadataV2

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

Formats the value using the given formatter.