Struct StdioProvider 

pub struct StdioProvider { /* private fields */ }

A ContextProvider backed by a child process over stdio.

Handshakes once on construction, caches the negotiated identity + capabilities, then splits the connection into independently-lockable halves: the write half (stdin) is locked only for the length of one line write, a dedicated reader task owns the read half and demultiplexes replies on their correlation id, and a [StdioControl] holds the child for teardown. A provider that negotiated Capabilities::correlation can therefore have several querys in flight at once — a slow one no longer head-of-line blocks the rest. A provider that did not negotiate correlation, and every verify (whose envelopes carry no id and so cannot be demultiplexed), stay strictly lock-step via no_id_lock, behaving exactly as the single-mutex transport did before (ADR 0002).

Implementations

impl StdioProvider

pub async fn spawn( id: impl Into<String>, program: &str, args: &[String], ) -> Result<Self, HostError>

Spawn a child-process provider, complete the handshake, and cache its declared identity + capabilities. id is the host-facing routing and consent key. Fails cleanly (killing the child) on a bad or incompatible handshake. On success the connection is split and the reader task launched, so replies can be demultiplexed from here on.

Trait Implementations

impl ContextProvider for StdioProvider

fn id(&self) -> &str

The provider’s host-facing id — its routing key and its consent key (SPEC.md §4 and §10).

fn info(&self) -> &ProviderInfo

Identity + declared data-flow direction, surfaced at consent time (SPEC.md §3, ).

fn capabilities(&self) -> &Capabilities

Capabilities negotiated at the handshake (SPEC.md §3) — which frame kinds and filters this provider serves, whether it upserts, does graph, is an embedder, or supports subscriptions.

fn query<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 ContextQuery, ) -> Pin<Box<dyn Future<Output = Result<ContextQueryResult, HostError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Answer a context query with budgeted, provenance-carrying frames (SPEC.md §5). The host — not the provider — enforces the budget and consent; a provider that over-runs its budget is caught by the host, not trusted (crate::host).

fn verify<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 VerifyRequest, ) -> Pin<Box<dyn Future<Output = Result<VerifyResponse, HostError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Revalidate frames the host already holds, without any frame body travelling (docs/context-reuse.md §4 context/verify).

fn shutdown<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), HostError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Shut the provider down cleanly (SPEC.md §3 lifecycle). In-process providers default to a no-op; transport-backed providers send shutdown and reap their child. Overridable.

impl Drop for StdioProvider

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.