use std::sync::Arc;
use anyhow::{Context, Result, anyhow};
use clap::Args;
use systemprompt_loader::ConfigLoader;
use systemprompt_mcp::services::McpOrchestrator;
use systemprompt_models::ai::tools::CallToolResult;
use systemprompt_runtime::AppContext;
use super::call_client::{
ToolCallParams, convert_content, execute_tool_call, list_available_tools,
};
use super::types::{McpCallOutput, McpToolContent};
use crate::context::CommandContext;
use crate::interactive::{Prompter, resolve_required};
use crate::session::{CliSessionContext, get_or_create_session};
use crate::shared::{CommandOutput, render_result};
#[derive(Debug, Args)]
#[command(
after_help = "Examples:\n systemprompt plugins mcp call systemprompt systemprompt \\\n \
--args '{\"command\":\"core skills list\"}'\n\n systemprompt plugins mcp call \
<server> <tool> -a '{\"key\":\"value\"}'"
)]
pub struct CallArgs {
#[arg(help = "MCP server name (required in non-interactive mode)")]
pub server: Option<String>,
#[arg(help = "Tool name to execute (required in non-interactive mode)")]
pub tool: Option<String>,
#[arg(short = 'a', long, help = "Tool arguments as JSON string")]
pub args: Option<String>,
#[arg(long, default_value = "30", help = "Timeout in seconds")]
pub timeout: u64,
}
pub(super) async fn execute(args: CallArgs, ctx: &CommandContext) -> Result<CommandOutput> {
let config = &ctx.cli;
let prompter = ctx.prompter();
let services_config = ConfigLoader::load().context("Failed to load services configuration")?;
let session_ctx = get_or_create_session(ctx).await?;
let server_arg = args.server.clone();
let tool_arg = args.tool.clone();
let timeout_secs = args.timeout;
let server_name = resolve_required(server_arg, "server", config, || {
prompt_server_selection(prompter, &services_config)
})?;
let _server_config = services_config
.mcp_servers
.get(&server_name)
.ok_or_else(|| anyhow!("MCP server '{}' not found in configuration", server_name))?;
let port = resolve_running_port(&server_name).await?;
let tool_name = resolve_required(tool_arg, "tool", config, || {
prompt_tool_selection(prompter, &server_name, port, &session_ctx, timeout_secs)
})?;
let tool_args: Option<serde_json::Value> = args
.args
.as_ref()
.map(|s| serde_json::from_str(s))
.transpose()
.context("Invalid JSON in --args")?;
let start_time = std::time::Instant::now();
let result = execute_tool_call(ToolCallParams {
server_name: &server_name,
port,
tool_name: &tool_name,
arguments: tool_args,
session_ctx: &session_ctx,
timeout_secs,
})
.await;
let execution_time_ms = start_time.elapsed().as_millis() as u64;
let (output, failure) = match result {
Ok(tool_result) => {
success_outcome(&tool_result, &server_name, &tool_name, execution_time_ms)
},
Err(e) => failure_outcome(e.to_string(), &server_name, &tool_name, execution_time_ms),
};
let card = CommandOutput::card_value(format!("Tool Execution: {}", tool_name), &output);
if let Some(msg) = failure {
render_result(&card, config);
return Err(anyhow!(msg));
}
Ok(card)
}
async fn resolve_running_port(server_name: &str) -> Result<u16> {
let ctx = AppContext::new()
.await
.context("Failed to initialize application context")?;
let manager = McpOrchestrator::new(
Arc::clone(ctx.db_pool()),
Arc::clone(ctx.app_paths_arc()),
ctx.mcp_registry().clone(),
)
.context("Failed to initialize MCP manager")?;
let running_servers = manager
.get_running_servers()
.await
.context("Failed to get running servers")?;
running_servers
.iter()
.find(|s| s.name == server_name)
.map(|s| s.port)
.ok_or_else(|| anyhow!("MCP server '{}' is not running", server_name))
}
fn success_outcome(
tool_result: &CallToolResult,
server_name: &str,
tool_name: &str,
execution_time_ms: u64,
) -> (McpCallOutput, Option<String>) {
let content: Vec<McpToolContent> = tool_result.content.iter().map(convert_content).collect();
let is_error = tool_result.is_error.unwrap_or(false);
let failure = is_error.then(|| {
let detail = content
.iter()
.filter_map(|c| c.text.as_deref())
.collect::<Vec<_>>()
.join("\n");
if detail.is_empty() {
format!(
"MCP tool '{}' on '{}' reported is_error=true with no message",
tool_name, server_name
)
} else {
format!(
"MCP tool '{}' on '{}' reported is_error=true: {}",
tool_name, server_name, detail
)
}
});
(
McpCallOutput {
server: server_name.to_owned(),
tool: tool_name.to_owned(),
success: !is_error,
content,
execution_time_ms,
error: failure.clone(),
},
failure,
)
}
fn failure_outcome(
message: String,
server_name: &str,
tool_name: &str,
execution_time_ms: u64,
) -> (McpCallOutput, Option<String>) {
(
McpCallOutput {
server: server_name.to_owned(),
tool: tool_name.to_owned(),
success: false,
content: vec![],
execution_time_ms,
error: Some(message.clone()),
},
Some(message),
)
}
pub fn prompt_server_selection(
prompter: &dyn Prompter,
config: &systemprompt_models::ServicesConfig,
) -> Result<String> {
let mut servers: Vec<String> = config.mcp_servers.keys().cloned().collect();
servers.sort();
if servers.is_empty() {
return Err(anyhow!("No MCP servers configured"));
}
let selection = prompter.select("Select MCP server", &servers)?;
Ok(servers[selection].clone())
}
fn prompt_tool_selection(
prompter: &dyn Prompter,
server_name: &str,
port: u16,
session_ctx: &CliSessionContext,
timeout_secs: u64,
) -> Result<String> {
let rt = tokio::runtime::Handle::current();
let tools = rt.block_on(async {
list_available_tools(server_name, port, session_ctx, timeout_secs).await
})?;
if tools.is_empty() {
return Err(anyhow!("No tools available on server '{}'", server_name));
}
let selection = prompter.select("Select tool to execute", &tools)?;
Ok(tools[selection].clone())
}