Struct ToolInfo 

#[non_exhaustive]
pub struct ToolInfo {
    pub name: String,
    pub title: Option<String>,
    pub description: Option<String>,
    pub input_schema: Value,
    pub output_schema: Option<Value>,
    pub annotations: Option<ToolAnnotations>,
    pub icons: Option<Vec<IconInfo>>,
    pub _meta: Option<Map<String, Value>>,
    pub execution: Option<ToolExecution>,
}

Tool information.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

Tool name (unique identifier)

title: Option<String>

Optional human-readable title (MCP 2025-11-25)

description: Option<String>

Human-readable description

input_schema: Value

JSON Schema for tool parameters

output_schema: Option<Value>

JSON Schema for the tool’s output type (MCP spec 2025-06-18).

When present, clients can validate and type-check the tool’s structured output. Code generators can create typed return structs instead of falling back to serde_json::Value.

annotations: Option<ToolAnnotations>

Tool annotations (hints and PMCP extensions)

icons: Option<Vec<IconInfo>>

Optional icons (MCP 2025-11-25)

_meta: Option<Map<String, Value>>

Optional metadata (e.g., for UI resource association in MCP Apps Extension)

execution: Option<ToolExecution>

Execution metadata declaring task support level (MCP 2025-11-25).

Implementations

impl ToolInfo

pub fn new( name: impl Into<String>, description: Option<String>, input_schema: Value, ) -> Self

Create a new ToolInfo without metadata or annotations.

pub fn with_annotations( name: impl Into<String>, description: Option<String>, input_schema: Value, annotations: ToolAnnotations, ) -> Self

Create a new ToolInfo with annotations.

Use this constructor when your tool has annotation hints. For output schema, chain ToolInfo::with_output_schema on the result.

Example

use pmcp::types::{ToolInfo, ToolAnnotations};
use serde_json::json;

let annotations = ToolAnnotations::new()
    .with_read_only(true)
    .with_output_type_name("MyResult");

let tool = ToolInfo::with_annotations(
    "my_tool",
    Some("My tool description".to_string()),
    json!({"type": "object"}),
    annotations,
).with_output_schema(json!({"type": "object", "properties": {"result": {"type": "string"}}}));

pub fn with_ui( name: impl Into<String>, description: Option<String>, input_schema: Value, ui_resource_uri: impl Into<String>, ) -> Self

Create a new ToolInfo with UI resource metadata.

Produces nested _meta format compatible with both MCP standard and ChatGPT:

• _meta.ui.resourceUri - MCP standard nested format
• _meta["openai/outputTemplate"] - ChatGPT alias for the same URI

pub fn with_output_schema(self, schema: Value) -> Self

Set the output schema for this tool (MCP spec 2025-06-18).

The output schema declares the JSON Schema that the tool’s structured output conforms to, enabling clients to validate and type-check results.

Example

use pmcp::types::ToolInfo;
use serde_json::json;

let tool = ToolInfo::new("my_tool", None, json!({"type": "object"}))
    .with_output_schema(json!({
        "type": "object",
        "properties": { "count": { "type": "integer" } }
    }));

pub fn with_widget_meta(self, widget: WidgetMeta) -> Self

Available on crate feature mcp-apps only.

Add widget metadata, deep-merging into existing _meta.

This merges WidgetMeta::to_meta_map() into the tool’s _meta, correctly combining nested ui objects so that ui.resourceUri and widget fields like ui.prefersBorder coexist.

Example

use pmcp::types::ToolInfo;
use pmcp::types::mcp_apps::WidgetMeta;
use serde_json::json;

let tool = ToolInfo::with_ui("my_tool", None, json!({"type": "object"}), "ui://w/app.html")
    .with_widget_meta(WidgetMeta::new().prefers_border(true));
// _meta.ui = { "resourceUri": "ui://w/app.html", "prefersBorder": true }

pub fn with_meta_entry(self, key: impl Into<String>, value: Value) -> Self

Add a single key-value pair to _meta, merging with existing entries.

If the key already exists and both values are objects, they are deep-merged. Otherwise the new value replaces the old (last-in wins).

This is the composable counterpart to ToolInfo::with_ui – multiple calls can be chained without overwriting each other’s keys.

Example

use pmcp::types::ToolInfo;
use serde_json::json;

let tool = ToolInfo::new("my_tool", None, json!({"type": "object"}))
    .with_meta_entry("ui", json!({"resourceUri": "ui://x"}))
    .with_meta_entry("execution", json!({"mode": "async"}));

pub fn widget_meta(&self) -> Option<&Map<String, Value>>

Return a reference to _meta if this tool has widget metadata.

Single-pass check: returns Some only when _meta contains a recognised widget key, None otherwise.

Trait Implementations

impl Clone for ToolInfo

fn clone(&self) -> ToolInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ToolInfo

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

Formats the value using the given formatter.

impl Default for ToolInfo

fn default() -> ToolInfo

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ToolInfo

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ToolInfo

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.