Struct StdioBuilder 

pub struct StdioBuilder { /* private fields */ }

Builds a stdio server and serves it on this process’s stdin and stdout.

The one-call form is Server::serve_stdio; this type exists for the case where the caller needs to change one of the two things that are genuinely decisions — the revision ceiling, or the framing limits.

Examples

let mut loop_ = StdioBuilder::new(Server::builder("greeter").build())
    .version(ProtocolVersion::V2025_06_18)
    .build();
let report = loop_.serve().await?;
eprintln!("{report:?}");

Implementations

impl StdioBuilder

pub fn new(server: Server) -> Self

A builder serving server over stdio.

pub fn auth(self, auth: AuthContext) -> Self

The principal this server’s peer acts as.

A stdio peer is the child process on the other end of a pipe, and there is nothing on a pipe to authenticate — no header, no token, no TLS peer identity. So unlike the HTTP transports, where the principal arrives with the request, here the deployment declares it and the crate holds it for the life of the session.

Needed because the alternative is unreachable rather than merely inconvenient: a scope-gated tool is invisible to an anonymous session (RegistryServer::call and the listing paths both read ctx.peer().auth()), so a stdio server that registers a Write-scoped tool could never serve it, and no setting existed that could change that. This method is that setting.

Defaults to AuthContext::anonymous, so a stdio server that says nothing serves exactly the primitives nobody had to authorise. Note the one lifetime difference from HTTP: this principal covers the whole connection, because there is no per-request credential here to differ from.

Examples

use protocol_droid::application::server::{Server, serve::StdioBuilder};
use protocol_droid::domain::registry::{AuthContext, Scope, ScopeSet};

let server = Server::builder("greeter").build();
let trusted = StdioBuilder::new(server)
    .auth(AuthContext::new("local", ScopeSet::empty().with(Scope::Write)));

pub const fn version(self, version: ProtocolVersion) -> Self

The newest revision this session is permitted to use before a peer says otherwise.

This is a ceiling, not an answer. The revision a peer is told in its handshake is settled from its own initialize; this only decides what the session gates on in the moment before that, and what it falls back to for a peer that never sent one.

Defaults to the newest revision with a handshake defined. The obvious alternative — the newest revision the crate knows — is 2026-07-28, which SEP-2575 removed initialize from, so a server that chose it would gate its whole life on a revision no peer can complete.

pub const fn config(self, config: StdioConfig) -> Self

The framing limits: frame ceiling and diagnostics writer.

pub fn build(self) -> ServeLoop<Stdin, Stdout, Stderr, ProfileBatching>

Assembles the loop this builder describes.

Infallible: everything it needs is either in self or derived from it by resolve, which is a pure function over a Negotiation this builder constructs itself.

Trait Implementations

impl Debug for StdioBuilder

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

Formats the value using the given formatter.