Struct CallToolResult 

pub struct CallToolResult {
    pub content: Vec<Content>,
    pub is_error: bool,
    pub structured_content: Option<Value>,
}

Result of a tool invocation.

This is the return type for tool handlers. Use the convenience constructors like CallToolResult::text, CallToolResult::json, or CallToolResult::error to create results easily.

Example

use tower_mcp::CallToolResult;

// Simple text result
let result = CallToolResult::text("Hello, world!");

// JSON result with structured content
let result = CallToolResult::json(serde_json::json!({"key": "value"}));

// Error result
let result = CallToolResult::error("Something went wrong");

Fields

content: Vec<Content>

The content items returned by the tool.

is_error: bool

Whether this result represents an error.

structured_content: Option<Value>

Optional structured content for programmatic access.

Implementations

impl CallToolResult

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

Create a text result.

This is the most common result type for tools that return plain text.

pub fn error(message: impl Into<String>) -> Self

Create an error result.

Use this when the tool encounters an error during execution. The is_error flag will be set to true.

pub fn json(value: Value) -> Self

Create a JSON result with structured content from a serde_json::Value.

The JSON value is serialized to pretty-printed text for display, and also stored in structured_content for programmatic access.

If you have a type that implements serde::Serialize, use from_serialize instead to avoid manual to_value() calls.

pub fn from_serialize(value: &impl Serialize) -> Result<Self, Error>

Create a JSON result from any serializable value.

This is a fallible alternative to json that accepts any serde::Serialize type and handles serialization errors gracefully. The value is serialized to a serde_json::Value, then delegated to json(), so structured_content is populated correctly.

Errors

Returns an error if the value cannot be serialized to JSON.

Example

use tower_mcp::CallToolResult;
use serde::Serialize;

#[derive(Serialize)]
struct SearchResult {
    title: String,
    score: f64,
}

let result = SearchResult {
    title: "Example".to_string(),
    score: 0.95,
};
let tool_result = CallToolResult::from_serialize(&result).unwrap();
assert!(!tool_result.is_error);
assert!(tool_result.structured_content.is_some());

pub fn image(data: impl Into<String>, mime_type: impl Into<String>) -> Self

Create a result with an image

pub fn audio(data: impl Into<String>, mime_type: impl Into<String>) -> Self

Create a result with audio

pub fn resource_link(uri: impl Into<String>) -> Self

Create a result with a resource link

pub fn resource_link_with_meta( uri: impl Into<String>, name: Option<String>, description: Option<String>, mime_type: Option<String>, ) -> Self

Create a result with a resource link including metadata

pub fn resource(resource: ResourceContent) -> Self

Create a result with an embedded resource

pub fn all_text(&self) -> String

Concatenate all text content items into a single string.

Non-text content items are skipped. Multiple text items are joined without a separator.

Example

use tower_mcp::CallToolResult;

let result = CallToolResult::text("hello world");
assert_eq!(result.all_text(), "hello world");

pub fn first_text(&self) -> Option<&str>

Get the text from the first Content::Text item.

Returns None if there are no text content items.

Example

use tower_mcp::CallToolResult;

let result = CallToolResult::text("hello");
assert_eq!(result.first_text(), Some("hello"));

Trait Implementations

impl Clone for CallToolResult

fn clone(&self) -> CallToolResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CallToolResult

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CallToolResult

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CallToolResult

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

where __S: Serializer,

Serialize this value into the given Serde serializer.