Struct Service 

pub struct Service { /* private fields */ }

Service builder. Holds name, bind address, the tonic router being assembled, the optional auth layer, and the optional in-process MCP listener config + custom spawner.

Implementations

impl Service

pub fn new(name: impl Into<String>) -> Self

Construct a new service. Initializes OTLP tracing as a side effect (idempotent; disabled if TONIN_TELEMETRY=off).

pub fn addr(self, addr: SocketAddr) -> Self

pub fn enable_mcp(self) -> Self

Enable the in-process MCP listener on the default port (0.0.0.0:50052). Same process, second port — MCP tool calls see the same AuthCtx task-local, share DB/cache/storage connections, and live or die with the gRPC server. To override the port use Service::mcp_addr.

What this currently does: spawns a hyper listener that answers GET /health with 200. The real MCP wire protocol (rmcp + #[tool] macros bridging each gRPC method) lands in a follow-up. This call only commits the framework to the “in-process, second port” lifecycle.

pub fn mcp_addr(self, addr: SocketAddr) -> Self

Enable the in-process MCP listener on a specific address. Useful for tests (bind :0 to grab a random free port) or for non-default deployments.

pub fn enable_mcp_with<H, F>(self, factory: F) -> Self

where H: McpServerHandler + Clone + Send + Sync + 'static, F: Fn() -> Result<H, Error> + Send + Sync + Clone + 'static,

Enable the in-process MCP listener with a custom handler. Use this to wire a #[tonin::mcp_expose]-generated adapter into the framework so MCP tools/list exposes one tool per gRPC method on the user’s impl.

factory is invoked once per MCP session by rmcp’s StreamableHttpService — returning a fresh handler instance each time (cheap if the handler is Arc-backed, which the macro-generated adapter is).

Example:

let svc = Service::new("greeter")
    .with_auth(auth::verifier())
    .enable_mcp_with(move || {
        Ok(GreeterImplMcpAdapter::new(GreeterImpl::new(state.clone())))
    });

pub fn with_auth<V: TokenVerifier>(self, verifier: V) -> Self

Install an auth verifier with the default auth::default::BearerHeaderExtractor.

Every inbound request runs the extractor → verifier chain. The resulting auth::AuthCtx is placed in request extensions AND in the auth::CURRENT_AUTH task-local for the handler’s execution.

For custom token extraction (cookies, custom headers, etc.) build an auth::AuthLayer directly and pass via Service::with_auth_layer.

pub fn with_auth_layer(self, layer: AuthLayer) -> Self

Install a fully-customized auth layer. Use this when you need a non-default token extractor (e.g. cookie-based auth).

pub fn without_auth(self) -> Self

Run all requests as anonymous. Handlers can still read AuthCtx::from(&req) — they’ll get AuthCtx { kind: PrincipalKind::Anonymous, .. }.

For services that genuinely don’t authenticate (read-only public APIs, internal-mesh-only with mTLS as the only check).

pub fn handler<S>(self, svc: S) -> Self

where S: Service<Request<BoxBody>, Response = Response<BoxBody>, Error = Infallible> + NamedService + Clone + Send + 'static, S::Future: Send + 'static,

Attach a tonic-generated service. Codegen will call this for the user.

Server-side trace-context extraction is installed once, the first time a handler is added; every subsequent handler shares the layer.

The auth layer (if configured via Service::with_auth) wraps each individual service via tonic’s per-service layering at run() time, so it applies uniformly to every handler.

pub async fn run(self) -> Result<()>