Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

feat(mcp): add toolCallTimeoutMs, timeout/reconnect/error handling

YeonGyu-Kim3b18ce9f3fb7
diff --git a/rust/crates/runtime/src/config.rs b/rust/crates/runtime/src/config.rs
index ccaf09ae..ed362f16 100644
--- a/rust/crates/runtime/src/config.rs
+++ b/rust/crates/runtime/src/config.rs
@@ -106,6 +106,7 @@ pub struct McpStdioServerConfig {
pub command: String,
pub args: Vec<String>,
pub env: BTreeMap<String, String>,
+ pub tool_call_timeout_ms: Option<u64>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
@@ -791,6 +792,7 @@ fn parse_mcp_server_config(
command: expect_string(object, "command", context)?.to_string(),
args: optional_string_array(object, "args", context)?.unwrap_or_default(),
env: optional_string_map(object, "env", context)?.unwrap_or_default(),
+ tool_call_timeout_ms: optional_u64(object, "toolCallTimeoutMs", context)?,
})),
"sse" => Ok(McpServerConfig::Sse(parse_mcp_remote_server_config(
object, context,
@@ -914,6 +916,27 @@ fn optional_u16(
}
}
+fn optional_u64(
+ object: &BTreeMap<String, JsonValue>,
+ key: &str,
+ context: &str,
+) -> Result<Option<u64>, ConfigError> {
+ match object.get(key) {
+ Some(value) => {
+ let Some(number) = value.as_i64() else {
+ return Err(ConfigError::Parse(format!(
+ "{context}: field {key} must be a non-negative integer"
+ )));
+ };
+ let number = u64::try_from(number).map_err(|_| {
+ ConfigError::Parse(format!("{context}: field {key} is out of range"))
+ })?;
+ Ok(Some(number))
+ }
+ None => Ok(None),
+ }
+}
+
fn parse_bool_map(value: &JsonValue, context: &str) -> Result<BTreeMap<String, bool>, ConfigError> {
let Some(map) = value.as_object() else {
return Err(ConfigError::Parse(format!(
diff --git a/rust/crates/runtime/src/mcp.rs b/rust/crates/runtime/src/mcp.rs
index b37ea339..e65cd084 100644
--- a/rust/crates/runtime/src/mcp.rs
+++ b/rust/crates/runtime/src/mcp.rs
@@ -84,10 +84,13 @@ pub fn mcp_server_signature(config: &McpServerConfig) -> Option<String> {
pub fn scoped_mcp_config_hash(config: &ScopedMcpServerConfig) -> String {
let rendered = match &config.config {
McpServerConfig::Stdio(stdio) => format!(
- "stdio|{}|{}|{}",
+ "stdio|{}|{}|{}|{}",
stdio.command,
render_command_signature(&stdio.args),
- render_env_signature(&stdio.env)
+ render_env_signature(&stdio.env),
+ stdio
+ .tool_call_timeout_ms
+ .map_or_else(String::new, |timeout_ms| timeout_ms.to_string())
),
McpServerConfig::Sse(remote) => format!(
"sse|{}|{}|{}|{}",
@@ -245,6 +248,7 @@ mod tests {
command: "uvx".to_string(),
args: vec!["mcp-server".to_string()],
env: BTreeMap::from([("TOKEN".to_string(), "secret".to_string())]),
+ tool_call_timeout_ms: None,
});
assert_eq!(
mcp_server_signature(&stdio),
diff --git a/rust/crates/runtime/src/mcp_client.rs b/rust/crates/runtime/src/mcp_client.rs
index e0e1f2c6..96a6db2f 100644
--- a/rust/crates/runtime/src/mcp_client.rs
+++ b/rust/crates/runtime/src/mcp_client.rs
@@ -3,6 +3,8 @@ use std::collections::BTreeMap;
use crate::config::{McpOAuthConfig, McpServerConfig, ScopedMcpServerConfig};
use crate::mcp::{mcp_server_signature, mcp_tool_prefix, normalize_name_for_mcp};
+pub const DEFAULT_MCP_TOOL_CALL_TIMEOUT_MS: u64 = 60_000;
+
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum McpClientTransport {
Stdio(McpStdioTransport),
@@ -18,6 +20,7 @@ pub struct McpStdioTransport {
pub command: String,
pub args: Vec<String>,
pub env: BTreeMap<String, String>,
+ pub tool_call_timeout_ms: Option<u64>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
@@ -75,6 +78,7 @@ impl McpClientTransport {
command: config.command.clone(),
args: config.args.clone(),
env: config.env.clone(),
+ tool_call_timeout_ms: config.tool_call_timeout_ms,
}),
McpServerConfig::Sse(config) => Self::Sse(McpRemoteTransport {
url: config.url.clone(),
@@ -105,6 +109,14 @@ impl McpClientTransport {
}
}
+impl McpStdioTransport {
+ #[must_use]
+ pub fn resolved_tool_call_timeout_ms(&self) -> u64 {
+ self.tool_call_timeout_ms
+ .unwrap_or(DEFAULT_MCP_TOOL_CALL_TIMEOUT_MS)
+ }
+}
+
impl McpClientAuth {
#[must_use]
pub fn from_oauth(oauth: Option<McpOAuthConfig>) -> Self {
@@ -136,6 +148,7 @@ mod tests {
command: "uvx".to_string(),
args: vec!["mcp-server".to_string()],
env: BTreeMap::from([("TOKEN".to_string(), "secret".to_string())]),
+ tool_call_timeout_ms: Some(15_000),
}),
};
@@ -154,6 +167,7 @@ mod tests {
transport.env.get("TOKEN").map(String::as_str),
Some("secret")
);
+ assert_eq!(transport.tool_call_timeout_ms, Some(15_000));
}
other => panic!("expected stdio transport, got {other:?}"),
}
diff --git a/rust/crates/runtime/src/mcp_stdio.rs b/rust/crates/runtime/src/mcp_stdio.rs
index b72b9ddb..7f5456a1 100644
--- a/rust/crates/runtime/src/mcp_stdio.rs
+++ b/rust/crates/runtime/src/mcp_stdio.rs
@@ -1,17 +1,30 @@
use std::collections::BTreeMap;
+use std::future::Future;
use std::io;
use std::process::Stdio;
+use std::time::Duration;
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use serde_json::Value as JsonValue;
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
use tokio::process::{Child, ChildStdin, ChildStdout, Command};
+use tokio::time::timeout;
use crate::config::{McpTransport, RuntimeConfig, ScopedMcpServerConfig};
use crate::mcp::mcp_tool_name;
use crate::mcp_client::{McpClientBootstrap, McpClientTransport, McpStdioTransport};
+#[cfg(test)]
+const MCP_INITIALIZE_TIMEOUT_MS: u64 = 200;
+#[cfg(not(test))]
+const MCP_INITIALIZE_TIMEOUT_MS: u64 = 10_000;
+
+#[cfg(test)]
+const MCP_LIST_TOOLS_TIMEOUT_MS: u64 = 300;
+#[cfg(not(test))]
+const MCP_LIST_TOOLS_TIMEOUT_MS: u64 = 30_000;
+
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(untagged)]
pub enum JsonRpcId {
@@ -220,6 +233,11 @@ pub struct UnsupportedMcpServer {
#[derive(Debug)]
pub enum McpServerManagerError {
Io(io::Error),
+ Transport {
+ server_name: String,
+ method: &'static str,
+ source: io::Error,
+ },
JsonRpc {
server_name: String,
method: &'static str,
@@ -230,6 +248,11 @@ pub enum McpServerManagerError {
method: &'static str,
details: String,
},
+ Timeout {
+ server_name: String,
+ method: &'static str,
+ timeout_ms: u64,
+ },
UnknownTool {
qualified_name: String,
},
@@ -242,6 +265,14 @@ impl std::fmt::Display for McpServerManagerError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Io(error) => write!(f, "{error}"),
+ Self::Transport {
+ server_name,
+ method,
+ source,
+ } => write!(
+ f,
+ "MCP server `{server_name}` transport failed during {method}: {source}"
+ ),
Self::JsonRpc {
server_name,
method,
@@ -259,6 +290,14 @@ impl std::fmt::Display for McpServerManagerError {
f,
"MCP server `{server_name}` returned invalid response for {method}: {details}"
),
+ Self::Timeout {
+ server_name,
+ method,
+ timeout_ms,
+ } => write!(
+ f,
+ "MCP server `{server_name}` timed out after {timeout_ms} ms while handling {method}"
+ ),
Self::UnknownTool { qualified_name } => {
write!(f, "unknown MCP tool `{qualified_name}`")
}
@@ -271,8 +310,10 @@ impl std::error::Error for McpServerManagerError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Io(error) => Some(error),
+ Self::Transport { source, .. } => Some(source),
Self::JsonRpc { .. }
| Self::InvalidResponse { .. }
+ | Self::Timeout { .. }
| Self::UnknownTool { .. }
| Self::UnknownServer { .. } => None,
}
@@ -361,69 +402,18 @@ impl McpServerManager {
let mut discovered_tools = Vec::new();
for server_name in server_names {
- self.ensure_server_ready(&server_name).await?;
+ let server_tools = self.discover_tools_for_server(&server_name).await?;
self.clear_routes_for_server(&server_name);
- let mut cursor = None;
- loop {
- let request_id = self.take_request_id();
- let response = {
- let server = self.server_mut(&server_name)?;
- let process = server.process.as_mut().ok_or_else(|| {
- McpServerManagerError::InvalidResponse {
- server_name: server_name.clone(),
- method: "tools/list",
- details: "server process missing after initialization".to_string(),
- }
- })?;
- process
- .list_tools(
- request_id,
- Some(McpListToolsParams {
- cursor: cursor.clone(),
- }),
- )
- .await?
- };
-
- if let Some(error) = response.error {
- return Err(McpServerManagerError::JsonRpc {
- server_name: server_name.clone(),
- method: "tools/list",
- error,
- });
- }
-
- let result =
- response
- .result
- .ok_or_else(|| McpServerManagerError::InvalidResponse {
- server_name: server_name.clone(),
- method: "tools/list",
- details: "missing result payload".to_string(),
- })?;
-
- for tool in result.tools {
- let qualified_name = mcp_tool_name(&server_name, &tool.name);
- self.tool_index.insert(
- qualified_name.clone(),
- ToolRoute {
- server_name: server_name.clone(),
- raw_name: tool.name.clone(),
- },
- );
- discovered_tools.push(ManagedMcpTool {
- server_name: server_name.clone(),
- qualified_name,
- raw_name: tool.name.clone(),
- tool,
- });
- }
-
- match result.next_cursor {
- Some(next_cursor) => cursor = Some(next_cursor),
- None => break,
- }
+ for tool in server_tools {
+ self.tool_index.insert(
+ tool.qualified_name.clone(),
+ ToolRoute {
+ server_name: tool.server_name.clone(),
+ raw_name: tool.raw_name.clone(),
+ },
+ );
+ discovered_tools.push(tool);
}
}
@@ -443,30 +433,42 @@ impl McpServerManager {
qualified_name: qualified_tool_name.to_string(),
})?;
+ let timeout_ms = self.tool_call_timeout_ms(&route.server_name)?;
+
self.ensure_server_ready(&route.server_name).await?;
let request_id = self.take_request_id();
- let response =
- {
- let server = self.server_mut(&route.server_name)?;
- let process = server.process.as_mut().ok_or_else(|| {
- McpServerManagerError::InvalidResponse {
- server_name: route.server_name.clone(),
- method: "tools/call",
- details: "server process missing after initialization".to_string(),
- }
- })?;
- process
- .call_tool(
- request_id,
- McpToolCallParams {
- name: route.raw_name,
- arguments,
- meta: None,
- },
- )
- .await?
- };
- Ok(response)
+ let response = {
+ let server = self.server_mut(&route.server_name)?;
+ let process = server.process.as_mut().ok_or_else(|| {
+ McpServerManagerError::InvalidResponse {
+ server_name: route.server_name.clone(),
+ method: "tools/call",
+ details: "server process missing after initialization".to_string(),
+ }
+ })?;
+ Self::run_process_request(
+ &route.server_name,
+ "tools/call",
+ timeout_ms,
+ process.call_tool(
+ request_id,
+ McpToolCallParams {
+ name: route.raw_name,
+ arguments,
+ meta: None,
+ },
+ ),
+ )
+ .await
+ };
+
+ if let Err(error) = &response {
+ if Self::should_reset_server(error) {
+ self.reset_server(&route.server_name).await?;
+ }
+ }
+
+ response
}
pub async fn shutdown(&mut self) -> Result<(), McpServerManagerError> {
@@ -504,33 +506,220 @@ impl McpServerManager {
JsonRpcId::Number(id)
}
- async fn ensure_server_ready(
- &mut self,
- server_name: &str,
- ) -> Result<(), McpServerManagerError> {
- let needs_spawn = self
+ fn tool_call_timeout_ms(&self, server_name: &str) -> Result<u64, McpServerManagerError> {
+ let server = self
.servers
.get(server_name)
- .map(|server| server.process.is_none())
.ok_or_else(|| McpServerManagerError::UnknownServer {
server_name: server_name.to_string(),
})?;
+ match &server.bootstrap.transport {
+ McpClientTransport::Stdio(transport) => Ok(transport.resolved_tool_call_timeout_ms()),
+ other => Err(McpServerManagerError::InvalidResponse {
+ server_name: server_name.to_string(),
+ method: "tools/call",
+ details: format!("unsupported MCP transport for stdio manager: {other:?}"),
+ }),
+ }
+ }
+
+ fn server_process_exited(&mut self, server_name: &str) -> Result<bool, McpServerManagerError> {
+ let server = self.server_mut(server_name)?;
+ match server.process.as_mut() {
+ Some(process) => Ok(process.has_exited()?),
+ None => Ok(false),
+ }
+ }
+
+ async fn discover_tools_for_server(
+ &mut self,
+ server_name: &str,
+ ) -> Result<Vec<ManagedMcpTool>, McpServerManagerError> {
+ let mut attempts = 0;
+
+ loop {
+ match self.discover_tools_for_server_once(server_name).await {
+ Ok(tools) => return Ok(tools),
+ Err(error) if attempts == 0 && Self::is_retryable_error(&error) => {
+ self.reset_server(server_name).await?;
+ attempts += 1;
+ }
+ Err(error) => {
+ if Self::should_reset_server(&error) {
+ self.reset_server(server_name).await?;
+ }
+ return Err(error);
+ }
+ }
+ }
+ }
+
+ async fn discover_tools_for_server_once(
+ &mut self,
+ server_name: &str,
+ ) -> Result<Vec<ManagedMcpTool>, McpServerManagerError> {
+ self.ensure_server_ready(server_name).await?;
+
+ let mut discovered_tools = Vec::new();
+ let mut cursor = None;
+ loop {
+ let request_id = self.take_request_id();
+ let response = {
+ let server = self.server_mut(server_name)?;
+ let process = server.process.as_mut().ok_or_else(|| {
+ McpServerManagerError::InvalidResponse {
+ server_name: server_name.to_string(),
+ method: "tools/list",
+ details: "server process missing after initialization".to_string(),
+ }
+ })?;
+ Self::run_process_request(
+ server_name,
+ "tools/list",
+ MCP_LIST_TOOLS_TIMEOUT_MS,
+ process.list_tools(
+ request_id,
+ Some(McpListToolsParams {
+ cursor: cursor.clone(),
+ }),
+ ),
+ )
+ .await?
+ };
+
+ if let Some(error) = response.error {
+ return Err(McpServerManagerError::JsonRpc {
+ server_name: server_name.to_string(),
+ method: "tools/list",
+ error,
+ });
+ }
+
+ let result =
+ response
+ .result
+ .ok_or_else(|| McpServerManagerError::InvalidResponse {
+ server_name: server_name.to_string(),
+ method: "tools/list",
+ details: "missing result payload".to_string(),
+ })?;
+
+ for tool in result.tools {
+ let qualified_name = mcp_tool_name(server_name, &tool.name);
+ discovered_tools.push(ManagedMcpTool {
+ server_name: server_name.to_string(),
+ qualified_name,
+ raw_name: tool.name.clone(),
+ tool,
+ });
+ }
+
+ match result.next_cursor {
+ Some(next_cursor) => cursor = Some(next_cursor),
+ None => break,
+ }
+ }
+
+ Ok(discovered_tools)
+ }
- if needs_spawn {
+ async fn reset_server(&mut self, server_name: &str) -> Result<(), McpServerManagerError> {
+ let mut process = {
let server = self.server_mut(server_name)?;
- server.process = Some(spawn_mcp_stdio_process(&server.bootstrap)?);
server.initialized = false;
+ server.process.take()
+ };
+
+ if let Some(process) = process.as_mut() {
+ let _ = process.shutdown().await;
}
- let needs_initialize = self
- .servers
- .get(server_name)
- .map(|server| !server.initialized)
- .ok_or_else(|| McpServerManagerError::UnknownServer {
+ Ok(())
+ }
+
+ fn is_retryable_error(error: &McpServerManagerError) -> bool {
+ matches!(
+ error,
+ McpServerManagerError::Transport { .. } | McpServerManagerError::Timeout { .. }
+ )
+ }
+
+ fn should_reset_server(error: &McpServerManagerError) -> bool {
+ matches!(
+ error,
+ McpServerManagerError::Transport { .. }
+ | McpServerManagerError::Timeout { .. }
+ | McpServerManagerError::InvalidResponse { .. }
+ )
+ }
+
+ async fn run_process_request<T, F>(
+ server_name: &str,
+ method: &'static str,
+ timeout_ms: u64,
+ future: F,
+ ) -> Result<T, McpServerManagerError>
+ where
+ F: Future<Output = io::Result<T>>,
+ {
+ match timeout(Duration::from_millis(timeout_ms), future).await {
+ Ok(Ok(value)) => Ok(value),
+ Ok(Err(error)) if error.kind() == io::ErrorKind::InvalidData => {
+ Err(McpServerManagerError::InvalidResponse {
+ server_name: server_name.to_string(),
+ method,
+ details: error.to_string(),
+ })
+ }
+ Ok(Err(source)) => Err(McpServerManagerError::Transport {
server_name: server_name.to_string(),
- })?;
+ method,
+ source,
+ }),
+ Err(_) => Err(McpServerManagerError::Timeout {
+ server_name: server_name.to_string(),
+ method,
+ timeout_ms,
+ }),
+ }
+ }
+
+ async fn ensure_server_ready(
+ &mut self,
+ server_name: &str,
+ ) -> Result<(), McpServerManagerError> {
+ if self.server_process_exited(server_name)? {
+ self.reset_server(server_name).await?;
+ }
+
+ let mut attempts = 0;
+ loop {
+ let needs_spawn = self
+ .servers
+ .get(server_name)
+ .map(|server| server.process.is_none())
+ .ok_or_else(|| McpServerManagerError::UnknownServer {
+ server_name: server_name.to_string(),
+ })?;
+
+ if needs_spawn {
+ let server = self.server_mut(server_name)?;
+ server.process = Some(spawn_mcp_stdio_process(&server.bootstrap)?);
+ server.initialized = false;
+ }
+
+ let needs_initialize = self
+ .servers
+ .get(server_name)
+ .map(|server| !server.initialized)
+ .ok_or_else(|| McpServerManagerError::UnknownServer {
+ server_name: server_name.to_string(),
+ })?;
+
+ if !needs_initialize {
+ return Ok(());
+ }
- if needs_initialize {
let request_id = self.take_request_id();
let response = {
let server = self.server_mut(server_name)?;
@@ -541,9 +730,28 @@ impl McpServerManager {
details: "server process missing before initialize".to_string(),
}
})?;
- process
- .initialize(request_id, default_initialize_params())
- .await?
+ Self::run_process_request(
+ server_name,
+ "initialize",
+ MCP_INITIALIZE_TIMEOUT_MS,
+ process.initialize(request_id, default_initialize_params()),
+ )
+ .await
+ };
+
+ let response = match response {
+ Ok(response) => response,
+ Err(error) if attempts == 0 && Self::is_retryable_error(&error) => {
+ self.reset_server(server_name).await?;
+ attempts += 1;
+ continue;
+ }
+ Err(error) => {
+ if Self::should_reset_server(&error) {
+ self.reset_server(server_name).await?;
+ }
+ return Err(error);
+ }
};
if let Some(error) = response.error {
@@ -555,18 +763,19 @@ impl McpServerManager {
}
if response.result.is_none() {
- return Err(McpServerManagerError::InvalidResponse {
+ let error = McpServerManagerError::InvalidResponse {
server_name: server_name.to_string(),
method: "initialize",
details: "missing result payload".to_string(),
- });
+ };
+ self.reset_server(server_name).await?;
+ return Err(error);
}
let server = self.server_mut(server_name)?;
server.initialized = true;
+ return Ok(());
}
-
- Ok(())
}
}
@@ -657,12 +866,15 @@ impl McpStdioProcess {
if line == "\r\n" {
break;
}
- if let Some(value) = line.strip_prefix("Content-Length:") {
- let parsed = value
- .trim()
- .parse::<usize>()
- .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
- content_length = Some(parsed);
+ let header = line.trim_end_matches(['\r', '\n']);
+ if let Some((name, value)) = header.split_once(':') {
+ if name.trim().eq_ignore_ascii_case("Content-Length") {
+ let parsed = value
+ .trim()
+ .parse::<usize>()
+ .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
+ content_length = Some(parsed);
+ }
}
}
@@ -703,9 +915,32 @@ impl McpStdioProcess {
method: impl Into<String>,
params: Option<TParams>,
) -> io::Result<JsonRpcResponse<TResult>> {
- let request = JsonRpcRequest::new(id, method, params);
+ let method = method.into();
+ let request = JsonRpcRequest::new(id.clone(), method.clone(), params);
self.send_request(&request).await?;
- self.read_response().await
+ let response = self.read_response().await?;
+
+ if response.jsonrpc != "2.0" {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidData,
+ format!(
+ "MCP response for {method} used unsupported jsonrpc version `{}`",
+ response.jsonrpc
+ ),
+ ));
+ }
+
+ if response.id != id {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidData,
+ format!(
+ "MCP response for {method} used mismatched id: expected {id:?}, got {:?}",
+ response.id
+ ),
+ ));
+ }
+
+ Ok(response)
}
pub async fn initialize(
@@ -756,9 +991,17 @@ impl McpStdioProcess {
self.child.wait().await
}
+ pub fn has_exited(&mut self) -> io::Result<bool> {
+ Ok(self.child.try_wait()?.is_some())
+ }
+
async fn shutdown(&mut self) -> io::Result<()> {
if self.child.try_wait()?.is_none() {
- self.child.kill().await?;
+ match self.child.kill().await {
+ Ok(()) => {}
+ Err(error) if error.kind() == io::ErrorKind::InvalidInput => {}
+ Err(error) => return Err(error),
+ }
}
let _ = self.child.wait().await?;
Ok(())
@@ -809,6 +1052,7 @@ mod tests {
use std::io::ErrorKind;
use std::os::unix::fs::PermissionsExt;
use std::path::{Path, PathBuf};
+ use std::sync::atomic::{AtomicU64, Ordering};
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
@@ -829,11 +1073,13 @@ mod tests {
};
fn temp_dir() -> PathBuf {
+ static NEXT_TEMP_DIR_ID: AtomicU64 = AtomicU64::new(0);
let nanos = SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("time should be after epoch")
.as_nanos();
- std::env::temp_dir().join(format!("runtime-mcp-stdio-{nanos}"))
+ let unique_id = NEXT_TEMP_DIR_ID.fetch_add(1, Ordering::Relaxed);
+ std::env::temp_dir().join(format!("runtime-mcp-stdio-{nanos}-{unique_id}"))
}
fn write_echo_script() -> PathBuf {
@@ -857,7 +1103,9 @@ mod tests {
let script_path = root.join("jsonrpc-mcp.py");
let script = [
"#!/usr/bin/env python3",
- "import json, sys",
+ "import json, os, sys",
+ "LOWERCASE_CONTENT_LENGTH = os.environ.get('MCP_LOWERCASE_CONTENT_LENGTH') == '1'",
+ "MISMATCHED_RESPONSE_ID = os.environ.get('MCP_MISMATCHED_RESPONSE_ID') == '1'",
"header = b''",
r"while not header.endswith(b'\r\n\r\n'):",
" chunk = sys.stdin.buffer.read(1)",
@@ -872,16 +1120,18 @@ mod tests {
"request = json.loads(payload.decode())",
r"assert request['jsonrpc'] == '2.0'",
r"assert request['method'] == 'initialize'",
+ "response_id = 'wrong-id' if MISMATCHED_RESPONSE_ID else request['id']",
+ "header_name = 'content-length' if LOWERCASE_CONTENT_LENGTH else 'Content-Length'",
r"response = json.dumps({",
r" 'jsonrpc': '2.0',",
- r" 'id': request['id'],",
+ r" 'id': response_id,",
r" 'result': {",
r" 'protocolVersion': request['params']['protocolVersion'],",
r" 'capabilities': {'tools': {}},",
r" 'serverInfo': {'name': 'fake-mcp', 'version': '0.1.0'}",
r" }",
r"}).encode()",
- r"sys.stdout.buffer.write(f'Content-Length: {len(response)}\r\n\r\n'.encode() + response)",
+ r"sys.stdout.buffer.write(f'{header_name}: {len(response)}\r\n\r\n'.encode() + response)",
"sys.stdout.buffer.flush()",
"",
]
@@ -900,7 +1150,9 @@ mod tests {
let script_path = root.join("fake-mcp-server.py");
let script = [
"#!/usr/bin/env python3",
- "import json, sys",
+ "import json, os, sys, time",
+ "TOOL_CALL_DELAY_MS = int(os.environ.get('MCP_TOOL_CALL_DELAY_MS', '0'))",
+ "INVALID_TOOL_CALL_RESPONSE = os.environ.get('MCP_INVALID_TOOL_CALL_RESPONSE') == '1'",
"",
"def read_message():",
" header = b''",
@@ -955,6 +1207,12 @@ mod tests {
" }",
" })",
" elif method == 'tools/call':",
+ " if INVALID_TOOL_CALL_RESPONSE:",
+ " sys.stdout.buffer.write(b'Content-Length: 5\\r\\n\\r\\nnope!')",
+ " sys.stdout.buffer.flush()",
+ " continue",
+ " if TOOL_CALL_DELAY_MS:",
+ " time.sleep(TOOL_CALL_DELAY_MS / 1000)",
" args = request['params'].get('arguments') or {}",
" if request['params']['name'] == 'fail':",
" send_message({",
@@ -1026,10 +1284,13 @@ mod tests {
let script_path = root.join("manager-mcp-server.py");
let script = [
"#!/usr/bin/env python3",
- "import json, os, sys",
+ "import json, os, sys, time",
"",
"LABEL = os.environ.get('MCP_SERVER_LABEL', 'server')",
"LOG_PATH = os.environ.get('MCP_LOG_PATH')",
+ "EXIT_AFTER_TOOLS_LIST = os.environ.get('MCP_EXIT_AFTER_TOOLS_LIST') == '1'",
+ "FAIL_ONCE_MODE = os.environ.get('MCP_FAIL_ONCE_MODE')",
+ "FAIL_ONCE_MARKER = os.environ.get('MCP_FAIL_ONCE_MARKER')",
"initialize_count = 0",
"",
"def log(method):",
@@ -1037,6 +1298,15 @@ mod tests {
" with open(LOG_PATH, 'a', encoding='utf-8') as handle:",
" handle.write(f'{method}\\n')",
"",
+ "def should_fail_once():",
+ " if not FAIL_ONCE_MODE or not FAIL_ONCE_MARKER:",
+ " return False",
+ " if os.path.exists(FAIL_ONCE_MARKER):",
+ " return False",
+ " with open(FAIL_ONCE_MARKER, 'w', encoding='utf-8') as handle:",
+ " handle.write(FAIL_ONCE_MODE)",
+ " return True",
+ "",
"def read_message():",
" header = b''",
r" while not header.endswith(b'\r\n\r\n'):",
@@ -1063,6 +1333,10 @@ mod tests {
" method = request['method']",
" log(method)",
" if method == 'initialize':",
+ " if FAIL_ONCE_MODE == 'initialize_hang' and should_fail_once():",
+ " log('initialize-hang')",
+ " while True:",
+ " time.sleep(1)",
" initialize_count += 1",
" send_message({",
" 'jsonrpc': '2.0',",
@@ -1091,7 +1365,12 @@ mod tests {
" ]",
" }",
" })",
+ " if EXIT_AFTER_TOOLS_LIST:",
+ " raise SystemExit(0)",
" elif method == 'tools/call':",
+ " if FAIL_ONCE_MODE == 'tool_call_disconnect' and should_fail_once():",
+ " log('tools/call-disconnect')",
+ " raise SystemExit(0)",
" args = request['params'].get('arguments') or {}",
" text = args.get('text', '')",
" send_message({",
@@ -1130,16 +1409,25 @@ mod tests {
command: "/bin/sh".to_string(),
args: vec![script_path.to_string_lossy().into_owned()],
env: BTreeMap::from([("MCP_TEST_TOKEN".to_string(), "secret-value".to_string())]),
+ tool_call_timeout_ms: None,
}),
};
McpClientBootstrap::from_scoped_config("stdio server", &config)
}
fn script_transport(script_path: &Path) -> crate::mcp_client::McpStdioTransport {
+ script_transport_with_env(script_path, BTreeMap::new())
+ }
+
+ fn script_transport_with_env(
+ script_path: &Path,
+ env: BTreeMap<String, String>,
+ ) -> crate::mcp_client::McpStdioTransport {
crate::mcp_client::McpStdioTransport {
command: "python3".to_string(),
args: vec![script_path.to_string_lossy().into_owned()],
- env: BTreeMap::new(),
+ env,
+ tool_call_timeout_ms: None,
}
}
@@ -1165,18 +1453,30 @@ mod tests {
label: &str,
log_path: &Path,
) -> ScopedMcpServerConfig {
+ manager_server_config_with_env(script_path, label, log_path, BTreeMap::new())
+ }
+
+ fn manager_server_config_with_env(
+ script_path: &Path,
+ label: &str,
+ log_path: &Path,
+ extra_env: BTreeMap<String, String>,
+ ) -> ScopedMcpServerConfig {
+ let mut env = BTreeMap::from([
+ ("MCP_SERVER_LABEL".to_string(), label.to_string()),
+ (
+ "MCP_LOG_PATH".to_string(),
+ log_path.to_string_lossy().into_owned(),
+ ),
+ ]);
+ env.extend(extra_env);
ScopedMcpServerConfig {
scope: ConfigSource::Local,
config: McpServerConfig::Stdio(McpStdioServerConfig {
command: "python3".to_string(),
args: vec![script_path.to_string_lossy().into_owned()],
- env: BTreeMap::from([
- ("MCP_SERVER_LABEL".to_string(), label.to_string()),
- (
- "MCP_LOG_PATH".to_string(),
- log_path.to_string_lossy().into_owned(),
- ),
- ]),
+ env,
+ tool_call_timeout_ms: None,
}),
}
}
@@ -1304,6 +1604,91 @@ mod tests {
});
}
+ #[test]
+ fn given_lowercase_content_length_when_initialize_then_response_parses() {
+ let runtime = Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .expect("runtime");
+ runtime.block_on(async {
+ let script_path = write_jsonrpc_script();
+ let transport = script_transport_with_env(
+ &script_path,
+ BTreeMap::from([(
+ "MCP_LOWERCASE_CONTENT_LENGTH".to_string(),
+ "1".to_string(),
+ )]),
+ );
+ let mut process = McpStdioProcess::spawn(&transport).expect("spawn transport directly");
+
+ let response = process
+ .initialize(
+ JsonRpcId::Number(8),
+ McpInitializeParams {
+ protocol_version: "2025-03-26".to_string(),
+ capabilities: json!({"roots": {}}),
+ client_info: McpInitializeClientInfo {
+ name: "runtime-tests".to_string(),
+ version: "0.1.0".to_string(),
+ },
+ },
+ )
+ .await
+ .expect("initialize roundtrip");
+
+ assert_eq!(response.id, JsonRpcId::Number(8));
+ assert_eq!(response.error, None);
+ assert!(response.result.is_some());
+
+ let status = process.wait().await.expect("wait for exit");
+ assert!(status.success());
+
+ cleanup_script(&script_path);
+ });
+ }
+
+ #[test]
+ fn given_mismatched_response_id_when_initialize_then_invalid_data_is_returned() {
+ let runtime = Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .expect("runtime");
+ runtime.block_on(async {
+ let script_path = write_jsonrpc_script();
+ let transport = script_transport_with_env(
+ &script_path,
+ BTreeMap::from([(
+ "MCP_MISMATCHED_RESPONSE_ID".to_string(),
+ "1".to_string(),
+ )]),
+ );
+ let mut process = McpStdioProcess::spawn(&transport).expect("spawn transport directly");
+
+ let error = process
+ .initialize(
+ JsonRpcId::Number(9),
+ McpInitializeParams {
+ protocol_version: "2025-03-26".to_string(),
+ capabilities: json!({"roots": {}}),
+ client_info: McpInitializeClientInfo {
+ name: "runtime-tests".to_string(),
+ version: "0.1.0".to_string(),
+ },
+ },
+ )
+ .await
+ .expect_err("mismatched response id should fail");
+
+ assert_eq!(error.kind(), ErrorKind::InvalidData);
+ assert!(error.to_string().contains("mismatched id"));
+
+ let status = process.wait().await.expect("wait for exit");
+ assert!(status.success());
+
+ cleanup_script(&script_path);
+ });
+ }
+
#[test]
fn direct_spawn_uses_transport_env() {
let runtime = Builder::new_current_thread()
@@ -1316,6 +1701,7 @@ mod tests {
command: "/bin/sh".to_string(),
args: vec![script_path.to_string_lossy().into_owned()],
env: BTreeMap::from([("MCP_TEST_TOKEN".to_string(), "direct-secret".to_string())]),
+ tool_call_timeout_ms: None,
};
let mut process = McpStdioProcess::spawn(&transport).expect("spawn transport directly");
let ready = process.read_available().await.expect("read ready");
@@ -1556,6 +1942,310 @@ mod tests {
});
}
+ #[test]
+ fn manager_times_out_slow_tool_calls() {
+ let runtime = Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .expect("runtime");
+ runtime.block_on(async {
+ let script_path = write_mcp_server_script();
+ let root = script_path.parent().expect("script parent");
+ let log_path = root.join("timeout.log");
+ let servers = BTreeMap::from([(
+ "slow".to_string(),
+ ScopedMcpServerConfig {
+ scope: ConfigSource::Local,
+ config: McpServerConfig::Stdio(McpStdioServerConfig {
+ command: "python3".to_string(),
+ args: vec![script_path.to_string_lossy().into_owned()],
+ env: BTreeMap::from([(
+ "MCP_TOOL_CALL_DELAY_MS".to_string(),
+ "200".to_string(),
+ )]),
+ tool_call_timeout_ms: Some(25),
+ }),
+ },
+ )]);
+ let mut manager = McpServerManager::from_servers(&servers);
+
+ manager.discover_tools().await.expect("discover tools");
+ let error = manager
+ .call_tool(&mcp_tool_name("slow", "echo"), Some(json!({"text": "slow"})))
+ .await
+ .expect_err("slow tool call should time out");
+
+ match error {
+ McpServerManagerError::Timeout {
+ server_name,
+ method,
+ timeout_ms,
+ } => {
+ assert_eq!(server_name, "slow");
+ assert_eq!(method, "tools/call");
+ assert_eq!(timeout_ms, 25);
+ }
+ other => panic!("expected timeout error, got {other:?}"),
+ }
+
+ manager.shutdown().await.expect("shutdown");
+ cleanup_script(&script_path);
+ let _ = fs::remove_file(log_path);
+ });
+ }
+
+ #[test]
+ fn manager_surfaces_parse_errors_from_tool_calls() {
+ let runtime = Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .expect("runtime");
+ runtime.block_on(async {
+ let script_path = write_mcp_server_script();
+ let servers = BTreeMap::from([(
+ "broken".to_string(),
+ ScopedMcpServerConfig {
+ scope: ConfigSource::Local,
+ config: McpServerConfig::Stdio(McpStdioServerConfig {
+ command: "python3".to_string(),
+ args: vec![script_path.to_string_lossy().into_owned()],
+ env: BTreeMap::from([(
+ "MCP_INVALID_TOOL_CALL_RESPONSE".to_string(),
+ "1".to_string(),
+ )]),
+ tool_call_timeout_ms: Some(1_000),
+ }),
+ },
+ )]);
+ let mut manager = McpServerManager::from_servers(&servers);
+
+ manager.discover_tools().await.expect("discover tools");
+ let error = manager
+ .call_tool(
+ &mcp_tool_name("broken", "echo"),
+ Some(json!({"text": "invalid-json"})),
+ )
+ .await
+ .expect_err("invalid json should fail");
+
+ match error {
+ McpServerManagerError::InvalidResponse {
+ server_name,
+ method,
+ details,
+ } => {
+ assert_eq!(server_name, "broken");
+ assert_eq!(method, "tools/call");
+ assert!(details.contains("expected ident") || details.contains("expected value"));
+ }
+ other => panic!("expected invalid response error, got {other:?}"),
+ }
+
+ manager.shutdown().await.expect("shutdown");
+ cleanup_script(&script_path);
+ });
+ }
+
+ #[test]
+ fn given_child_exits_after_discovery_when_calling_twice_then_second_call_succeeds_after_reset() {
+ let runtime = Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .expect("runtime");
+ runtime.block_on(async {
+ let script_path = write_manager_mcp_server_script();
+ let root = script_path.parent().expect("script parent");
+ let log_path = root.join("dropping.log");
+ let servers = BTreeMap::from([(
+ "alpha".to_string(),
+ manager_server_config_with_env(
+ &script_path,
+ "alpha",
+ &log_path,
+ BTreeMap::from([(
+ "MCP_EXIT_AFTER_TOOLS_LIST".to_string(),
+ "1".to_string(),
+ )]),
+ ),
+ )]);
+ let mut manager = McpServerManager::from_servers(&servers);
+
+ manager.discover_tools().await.expect("discover tools");
+ let first_error = manager
+ .call_tool(
+ &mcp_tool_name("alpha", "echo"),
+ Some(json!({"text": "reconnect"})),
+ )
+ .await
+ .expect_err("first call should fail after transport drops");
+
+ match first_error {
+ McpServerManagerError::Transport {
+ server_name,
+ method,
+ source,
+ } => {
+ assert_eq!(server_name, "alpha");
+ assert_eq!(method, "tools/call");
+ assert_eq!(source.kind(), ErrorKind::UnexpectedEof);
+ }
+ other => panic!("expected transport error, got {other:?}"),
+ }
+
+ let response = manager
+ .call_tool(
+ &mcp_tool_name("alpha", "echo"),
+ Some(json!({"text": "reconnect"})),
+ )
+ .await
+ .expect("second tool call should succeed after reset");
+
+ assert_eq!(
+ response
+ .result
+ .as_ref()
+ .and_then(|result| result.structured_content.as_ref())
+ .and_then(|value| value.get("server")),
+ Some(&json!("alpha"))
+ );
+ let log = fs::read_to_string(&log_path).expect("read log");
+ assert_eq!(
+ log.lines().collect::<Vec<_>>(),
+ vec!["initialize", "tools/list", "initialize", "tools/call"]
+ );
+
+ manager.shutdown().await.expect("shutdown");
+ cleanup_script(&script_path);
+ });
+ }
+
+ #[test]
+ fn given_initialize_hangs_once_when_discover_tools_then_manager_retries_and_succeeds() {
+ let runtime = Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .expect("runtime");
+ runtime.block_on(async {
+ let script_path = write_manager_mcp_server_script();
+ let root = script_path.parent().expect("script parent");
+ let log_path = root.join("initialize-hang.log");
+ let marker_path = root.join("initialize-hang.marker");
+ let servers = BTreeMap::from([(
+ "alpha".to_string(),
+ manager_server_config_with_env(
+ &script_path,
+ "alpha",
+ &log_path,
+ BTreeMap::from([
+ (
+ "MCP_FAIL_ONCE_MODE".to_string(),
+ "initialize_hang".to_string(),
+ ),
+ (
+ "MCP_FAIL_ONCE_MARKER".to_string(),
+ marker_path.to_string_lossy().into_owned(),
+ ),
+ ]),
+ ),
+ )]);
+ let mut manager = McpServerManager::from_servers(&servers);
+
+ let tools = manager.discover_tools().await.expect("discover tools after retry");
+
+ assert_eq!(tools.len(), 1);
+ assert_eq!(tools[0].qualified_name, mcp_tool_name("alpha", "echo"));
+ let log = fs::read_to_string(&log_path).expect("read log");
+ assert_eq!(
+ log.lines().collect::<Vec<_>>(),
+ vec!["initialize", "initialize-hang", "initialize", "tools/list"]
+ );
+
+ manager.shutdown().await.expect("shutdown");
+ cleanup_script(&script_path);
+ });
+ }
+
+ #[test]
+ fn given_tool_call_disconnects_once_when_calling_twice_then_manager_resets_and_next_call_succeeds() {
+ let runtime = Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .expect("runtime");
+ runtime.block_on(async {
+ let script_path = write_manager_mcp_server_script();
+ let root = script_path.parent().expect("script parent");
+ let log_path = root.join("tool-call-disconnect.log");
+ let marker_path = root.join("tool-call-disconnect.marker");
+ let servers = BTreeMap::from([(
+ "alpha".to_string(),
+ manager_server_config_with_env(
+ &script_path,
+ "alpha",
+ &log_path,
+ BTreeMap::from([
+ (
+ "MCP_FAIL_ONCE_MODE".to_string(),
+ "tool_call_disconnect".to_string(),
+ ),
+ (
+ "MCP_FAIL_ONCE_MARKER".to_string(),
+ marker_path.to_string_lossy().into_owned(),
+ ),
+ ]),
+ ),
+ )]);
+ let mut manager = McpServerManager::from_servers(&servers);
+
+ manager.discover_tools().await.expect("discover tools");
+ let first_error = manager
+ .call_tool(&mcp_tool_name("alpha", "echo"), Some(json!({"text": "first"})))
+ .await
+ .expect_err("first tool call should fail when transport drops");
+
+ match first_error {
+ McpServerManagerError::Transport {
+ server_name,
+ method,
+ source,
+ } => {
+ assert_eq!(server_name, "alpha");
+ assert_eq!(method, "tools/call");
+ assert_eq!(source.kind(), ErrorKind::UnexpectedEof);
+ }
+ other => panic!("expected transport error, got {other:?}"),
+ }
+
+ let response = manager
+ .call_tool(&mcp_tool_name("alpha", "echo"), Some(json!({"text": "second"})))
+ .await
+ .expect("second tool call should succeed after reset");
+
+ assert_eq!(
+ response
+ .result
+ .as_ref()
+ .and_then(|result| result.structured_content.as_ref())
+ .and_then(|value| value.get("echoed")),
+ Some(&json!("second"))
+ );
+ let log = fs::read_to_string(&log_path).expect("read log");
+ assert_eq!(
+ log.lines().collect::<Vec<_>>(),
+ vec![
+ "initialize",
+ "tools/list",
+ "tools/call",
+ "tools/call-disconnect",
+ "initialize",
+ "tools/call",
+ ]
+ );
+
+ manager.shutdown().await.expect("shutdown");
+ cleanup_script(&script_path);
+ });
+ }
+
#[test]
fn manager_records_unsupported_non_stdio_servers_without_panicking() {
let servers = BTreeMap::from([