Add structured output to the Rust weather server and client

Both tools now declare an outputSchema and return structuredContent
alongside the human-readable text.

get_alerts declares Vec<Alert> as its output schema, so its structured
content is a top-level JSON array rather than an array nested in an
object. Protocol revision 2026-07-28 is the first to allow this: through
2025-11-25 an outputSchema had to be object-rooted, forcing a wrapper key
for what is naturally a list. No alerts is now simply [], not a special
case. get_forecast returns an object, for contrast.

Failure paths return a tool-level error result rather than a bare text
result: a tool that declares an outputSchema MUST return conforming
structured content, so a path with no data to return has to fail.

The client compiles every declared outputSchema at connect time and
validates results against it, per the spec's client-side SHOULD. rmcp
does not do this for you; its docs point at the jsonschema crate, which
is the one new dependency here. The client also prefers
structuredContent when forwarding to the model.

The client no longer treats a missing .env as fatal, and checks for
ANTHROPIC_API_KEY after connecting rather than before. Connecting and
listing tools needs no credentials, so this matches the Python and
TypeScript clients, which report the missing key and exit cleanly - the
behaviour the smoke tests rely on.

This supersedes modelcontextprotocol#143. That PR bumped rmcp 0.3 -> 1.4 and failed CI
because the 0.3 #[tool] macro API does not survive the jump; the rewrite
here was required either way, so the bump is folded in and taken further,
to 3.0.0-beta.2 - the first version with the 2026-07-28 model.

Two rmcp gaps worth knowing about, both discovered by connecting a
TypeScript SDK client to this server:

list_tools is hand-written. #[tool_handler] generates one that hardcodes
ttl_ms: None, cache_scope: None, but both are required on a paginated
result at 2026-07-28 (SEP-2549), and a strict client rejects the response
outright. The macro skips generation when the impl defines the method.
Without this workaround the server is unusable from such a client.

get_info does not pin ProtocolVersion::V_2026_07_28. rmcp's server never
implements server/discover - the string appears only in its client - so
it cannot serve a modern-era opening, and pinning the version only
overstates support.

Note also that rmcp sends an array-rooted schema as written on every
connection; it does not project it down to the object form older
revisions require, the way the TypeScript SDK does. Adopting an array
root is therefore a breaking change for pre-2026-07-28 clients. The
README says so.

The model identifier moves to claude-sonnet-5, the current Sonnet. All
four quickstart clients now name the same model; they had drifted onto three
different ones, and the Rust client was on claude-sonnet-4-20250514, which is
past end of life and warns on every run.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: olaservo

mcp-client-rust/Cargo.lock

@@ -6,7 +6,8 @@ edition = "2024"
 [dependencies]
 anyhow = "1.0.100"
 genai = "0.4.2"
-rmcp = { version = "0.8.0", features = ["server", "client", "transport-io", "transport-child-process"] }
+jsonschema = "0.35"
+rmcp = { version = "3.0.0-beta.2", features = ["server", "client", "transport-io", "transport-child-process"] }
 tokio = { version = "1.47.1", features = ['full']}
 tracing = "0.1.41"
 tracing-subscriber = {version = "0.3", features = ["env-filter"]}

mcp-client-rust/Cargo.toml

@@ -1,3 +1,14 @@
 # An LLM-Powered Chatbot MCP Client written in Rust
 
 See the [Build an MCP client](https://modelcontextprotocol.io/docs/develop/build-client) tutorial for more information.
+
+## Structured output
+
+When a tool declares an `outputSchema`, the spec says clients **SHOULD** validate the structured result against it. rmcp does not do this for you — its docs point at the [`jsonschema`](https://crates.io/crates/jsonschema) crate, which is what this client uses. It happens in two steps:
+
+- At connect time each declared `outputSchema` is compiled once into a `Validator`, keyed by tool name.
+- After each call `validate_tool_output` checks the result: a non-error result from a schema-declaring tool must carry `structuredContent`, and that content must conform. Error results are exempt — they carry a message, not data.
+
+Note that `outputSchema` is not necessarily an object schema. As of protocol revision `2026-07-28` its root may be any JSON Schema, so a tool may answer with a top-level array (the weather server's `get_alerts` does).
+
+When a result carries `structuredContent`, the client forwards that to the model in preference to re-serializing the whole `CallToolResult` — it is the data itself rather than prose describing it.

mcp-client-rust/README.md

@@ -3,19 +3,26 @@ use genai::Client;
 use genai::chat::{
     ChatMessage, ChatRequest, ChatResponse, ContentPart, Tool as GenaiTool, ToolResponse,
 };
-use rmcp::model::{CallToolRequestParam, Tool as McpTool};
+use jsonschema::Validator;
+use rmcp::model::{CallToolRequestParams, CallToolResult, Tool as McpTool};
 use rmcp::service::{RoleClient, RunningService, ServiceExt};
 use rmcp::transport::TokioChildProcess;
 use serde_json::Value;
+use std::collections::HashMap;
 use tokio::io::{self, AsyncBufReadExt, BufReader};
 use tokio::process::Command;
 
-const MODEL_ANTHROPIC: &str = "claude-sonnet-4-20250514";
+const MODEL_ANTHROPIC: &str = "claude-sonnet-5";
 
 struct MCPClient {
     anthropic: Client,
     session: Option<RunningService<RoleClient, ()>>,
     tools: Vec<GenaiTool>,
+    /// The compiled `outputSchema` of every tool that declared one, keyed by
+    /// tool name. The spec says clients SHOULD validate structured results
+    /// against it, so we compile once at connect time and check on every call.
+    /// rmcp does not do this for you — it points at the `jsonschema` crate.
+    output_schemas: HashMap<String, Validator>,
 }
 
 impl MCPClient {
@@ -24,9 +31,29 @@ impl MCPClient {
             anthropic: Client::default(),
             session: None,
             tools: Vec::new(),
+            output_schemas: HashMap::new(),
         })
     }
 
+    /// Enforce the spec's contract on a tool that declared an `outputSchema`:
+    /// the result MUST carry conforming structured content. Error results are
+    /// exempt — they carry a message, not data.
+    fn validate_tool_output(&self, name: &str, result: &CallToolResult) -> Result<()> {
+        let Some(validator) = self.output_schemas.get(name) else {
+            return Ok(());
+        };
+        if result.is_error.unwrap_or(false) {
+            return Ok(());
+        }
+        let Some(structured) = &result.structured_content else {
+            bail!("Tool {name} declares an output schema but returned no structured content");
+        };
+        if let Err(error) = validator.validate(structured) {
+            bail!("Structured content from tool {name} does not match its output schema: {error}");
+        }
+        Ok(())
+    }
+
     async fn connect_to_server(&mut self, server_args: &[String]) -> Result<()> {
         if self.session.is_some() {
             bail!("Client is already connected to a server");
@@ -52,6 +79,19 @@ impl MCPClient {
 
         println!("Connected to server with tools: {tool_names:?}");
 
+        // An outputSchema root may be any JSON Schema as of protocol revision
+        // 2026-07-28 — an object, but equally an array or a primitive.
+        for tool in &rmcp_tools {
+            let Some(schema) = &tool.output_schema else {
+                continue;
+            };
+            let schema = Value::Object(schema.as_ref().clone());
+            let validator = Validator::new(&schema).with_context(|| {
+                format!("Failed to compile output schema of tool {}", tool.name)
+            })?;
+            self.output_schemas.insert(tool.name.to_string(), validator);
+        }
+
         self.tools = convert_tools(&rmcp_tools);
         self.session = Some(session);
         Ok(())
@@ -93,16 +133,26 @@ impl MCPClient {
                 ));
 
                 // Query the MCP server
+                let mut params = CallToolRequestParams::new(tool_call.fn_name.clone());
+                if let Some(arguments) = tool_call.fn_arguments.as_object().cloned() {
+                    params = params.with_arguments(arguments);
+                }
                 let tool_result = session
-                    .call_tool(CallToolRequestParam {
-                        name: tool_call.fn_name.clone().into(),
-                        arguments: tool_call.fn_arguments.as_object().cloned(),
-                    })
+                    .call_tool(params)
                     .await
                     .with_context(|| format!("Tool call {} failed", tool_call.fn_name))?;
 
-                let payload = serde_json::to_string(&tool_result)
-                    .context("Failed to serialize tool result")?;
+                self.validate_tool_output(&tool_call.fn_name, &tool_result)?;
+
+                // Prefer the structured result when the tool provides one: it
+                // is the data itself rather than prose describing it. Note that
+                // it need not be a JSON object — get_alerts answers with a
+                // top-level array.
+                let payload = match &tool_result.structured_content {
+                    Some(structured) => serde_json::to_string(structured),
+                    None => serde_json::to_string(&tool_result),
+                }
+                .context("Failed to serialize tool result")?;
 
                 tool_results.push(ContentPart::ToolResponse(ToolResponse::new(
                     tool_call.call_id.clone(),
@@ -179,7 +229,10 @@ impl MCPClient {
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    dotenvy::dotenv().context("Failed to load env file")?;
+    // Load .env if present. Its absence is not an error: the API key may come
+    // from the environment, and connecting to a server does not need one at
+    // all — which is what lets this client be smoke-tested without credentials.
+    let _ = dotenvy::dotenv();
 
     let mut args = std::env::args();
     let _ = args.next();
@@ -194,6 +247,17 @@ async fn main() -> Result<()> {
 
     let result = async {
         client.connect_to_server(&server_args).await?;
+
+        // Connecting and listing tools needs no credentials; querying them
+        // does. Matching the Python and TypeScript clients, report and exit
+        // rather than failing, so the connection itself can be exercised
+        // without a key.
+        if std::env::var("ANTHROPIC_API_KEY").is_err() {
+            println!("\nNo ANTHROPIC_API_KEY found. To query these tools with Claude, set your API key:");
+            println!("  export ANTHROPIC_API_KEY=your-api-key-here");
+            return Ok(());
+        }
+
         client.chat_loop().await
     }
     .await;