Struct TypedToolWithOutput 

pub struct TypedToolWithOutput<TIn, TOut, F>
where
    TIn: DeserializeOwned + Send + Sync + 'static,
    TOut: Serialize + Send + Sync + 'static,
    F: Fn(TIn, RequestHandlerExtra) -> Pin<Box<dyn Future<Output = Result<TOut>> + Send>> + Send + Sync,
{ /* private fields */ }

Available on non-WebAssembly only.

A typed tool with both input and output type safety

This variant provides type safety for both input arguments and return values. While output schemas are not part of the MCP protocol, they’re useful for testing, documentation, and API contracts.

Implementations

impl<TIn, TOut, F> TypedToolWithOutput<TIn, TOut, F>

where TIn: DeserializeOwned + Send + Sync + 'static, TOut: Serialize + Send + Sync + 'static, F: Fn(TIn, RequestHandlerExtra) -> Pin<Box<dyn Future<Output = Result<TOut>> + Send>> + Send + Sync,

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

where TIn: JsonSchema, TOut: JsonSchema,

Available on crate feature schema-generation only.

Create a new typed tool with automatic input and output schema generation

pub fn new_input_only(name: impl Into<String>, handler: F) -> Self

where TIn: JsonSchema,

Available on crate feature schema-generation only.

Create with only input schema generation (output schema omitted)

pub fn new_with_schemas( name: impl Into<String>, input_schema: Value, output_schema: Option<Value>, handler: F, ) -> Self

Create with manually provided schemas

pub fn with_description(self, description: impl Into<String>) -> Self

Set the description for this tool

pub fn with_annotations(self, annotations: ToolAnnotations) -> Self

Set annotations for this tool.

These annotations will be merged with the auto-generated output schema annotation. User-provided hints (readOnlyHint, destructiveHint, etc.) will be combined with the output schema annotation.

Example

use pmcp::server::typed_tool::TypedToolWithOutput;
use pmcp::types::ToolAnnotations;
use serde::{Deserialize, Serialize};
use schemars::JsonSchema;

#[derive(Debug, Deserialize, JsonSchema)]
struct QueryArgs { sql: String }

#[derive(Debug, Serialize, JsonSchema)]
struct QueryResult { rows: Vec<String> }

let tool = TypedToolWithOutput::new("query", |args: QueryArgs, _| {
    Box::pin(async move {
        Ok(QueryResult { rows: vec![] })
    })
})
.with_description("Execute SQL query")
.with_annotations(
    ToolAnnotations::new()
        .with_read_only(true)
        .with_idempotent(true)
);
// Tool now has both readOnlyHint and auto-generated pmcp:outputSchema

pub fn read_only(self) -> Self

Mark this tool as read-only (convenience method).

pub fn destructive(self) -> Self

Mark this tool as destructive (convenience method).

pub fn idempotent(self) -> Self

Mark this tool as idempotent (convenience method).

pub fn open_world(self) -> Self

Mark this tool as interacting with external systems (convenience method).

pub fn output_schema(&self) -> Option<&Value>

Get the output schema (if any) for testing/documentation purposes

Trait Implementations

impl<TIn, TOut, F> Debug for TypedToolWithOutput<TIn, TOut, F>

where TIn: DeserializeOwned + Send + Sync + 'static, TOut: Serialize + Send + Sync + 'static, F: Fn(TIn, RequestHandlerExtra) -> Pin<Box<dyn Future<Output = Result<TOut>> + Send>> + Send + Sync,

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

Formats the value using the given formatter.

impl<TIn, TOut, F> ToolHandler for TypedToolWithOutput<TIn, TOut, F>

where TIn: DeserializeOwned + Send + Sync + 'static, TOut: Serialize + Send + Sync + 'static, F: Fn(TIn, RequestHandlerExtra) -> Pin<Box<dyn Future<Output = Result<TOut>> + Send>> + Send + Sync,

fn handle<'life0, 'async_trait>( &'life0 self, args: Value, extra: RequestHandlerExtra, ) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>>

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

Handle a tool call with the given arguments.

fn metadata(&self) -> Option<ToolInfo>

Get tool metadata including description and schema. Returns None to use default empty metadata.