external_client.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/mcp/external_client.h>
#include <entropic/types/logging.h>
 
#include <nlohmann/json.hpp>
 
#include <algorithm>
#include <set>
 
static auto logger = entropic::log::get("mcp.external_client");
 
namespace entropic {
 
ExternalMCPClient::ExternalMCPClient(
    std::string name,
    std::unique_ptr<Transport> transport)
    : name_(std::move(name)),
      transport_(std::move(transport)) {}
 
bool ExternalMCPClient::connect() {
    if (!transport_->open()) {
        logger->error("Transport open failed for '{}'", name_);
        return false;
    }
 
    if (!send_initialize()) {
        logger->error("MCP initialize failed for '{}'", name_);
        transport_->close();
        return false;
    }
 
    if (!query_tools()) {
        logger->warn("tools/list failed for '{}' — "
                     "connected with 0 tools", name_);
    }
 
    logger->info("Connected to '{}': {} tools",
                 name_, cached_tool_names_.size());
    return true;
}
 
void ExternalMCPClient::disconnect() {
    transport_->close();
    std::lock_guard<std::mutex> lock(tools_mutex_);
    cached_tools_json_ = "[]";
    cached_tool_names_.clear();
    logger->info("Disconnected from '{}'", name_);
}
 
std::string ExternalMCPClient::list_tools() const {
    std::lock_guard<std::mutex> lock(tools_mutex_);
    return cached_tools_json_;
}
 
std::string ExternalMCPClient::empty_response_envelope(
    const std::string& tool_name) const {
    if (transport_->is_interrupted()) {
        return build_response(
            "Error: tool '" + name_ + "." + tool_name +
            "' was not attempted — the transport is interrupted. "
            "The interrupt is released at the start of the next run.",
            true);
    }
    return build_response(
        "Error: tool '" + name_ + "." + tool_name +
        "' timed out or the transport failed.", true);
}
 
std::string ExternalMCPClient::execute(
    const std::string& tool_name,
    const std::string& args_json) {
 
    if (!transport_->is_connected()) {
        // gh#150: the leading "Error:" is load-bearing, not decoration.
        // classify_tool_result routes on the TEXT via looks_like_tool_error,
        // which matches a leading "error"/"[error]"/JSON-error shape. This
        // message used to start with "Server '...'", so a failed call was
        // logged status=ok and counted as a success — the reporting
        // consumer watched every external call fail while the logs said
        // everything was fine.
        return build_response(
            "Error: server '" + name_ + "' is disconnected. "
            "Tool '" + name_ + "." + tool_name + "' unavailable.",
            true);
    }
 
    nlohmann::json params;
    params["name"] = tool_name;
    try {
        params["arguments"] = nlohmann::json::parse(args_json);
    } catch (...) {
        params["arguments"] = nlohmann::json::object();
    }
 
    int request_id = 0;
    auto request = build_request_id(
        "tools/call", params.dump(), request_id);
    auto response = transport_->send_request(
        request, DEFAULT_TIMEOUT_MS);
 
    auto problem = response_problem(tool_name, response, request_id);
    if (!problem.empty()) {
        return problem;
    }
 
    auto result_text = extract_tool_result(response);
    return build_response(result_text);
}
 
std::string ExternalMCPClient::response_problem(
    const std::string& tool_name,
    const std::string& response,
    int expected_id) const {
    if (response.empty()) {
        return empty_response_envelope(tool_name);
    }
    if (!response_matches(response, expected_id)) {
        return mismatched_response_envelope(tool_name, expected_id);
    }
    return {};
}
 
std::string ExternalMCPClient::mismatched_response_envelope(
    const std::string& tool_name, int expected_id) const {
    logger->error("Server '{}' answered request {} with a response carrying "
                  "a different id; discarding it rather than returning "
                  "another request's result for tool '{}'",
                  name_, expected_id, tool_name);
    return build_response(
        "Error: tool '" + name_ + "." + tool_name +
        "' got a response that did not answer it (JSON-RPC id mismatch). "
        "The transport had a stale reply queued from an abandoned request; "
        "it has been discarded. Retry the call.", true);
}
 
static std::vector<std::string> names_diff(
    const std::set<std::string>& a, const std::set<std::string>& b) {
    std::vector<std::string> out;
    std::set_difference(a.begin(), a.end(), b.begin(), b.end(),
                        std::back_inserter(out));
    return out;
}
 
std::pair<std::vector<std::string>, std::vector<std::string>>
ExternalMCPClient::refresh_tools() {
    auto snapshot = [this] {
        std::lock_guard<std::mutex> lock(tools_mutex_);
        return std::set<std::string>(cached_tool_names_.begin(),
                                     cached_tool_names_.end());
    };
 
    std::set<std::string> old_names = snapshot();
    query_tools();
    std::set<std::string> new_names = snapshot();
 
    auto added = names_diff(new_names, old_names);
    auto removed = names_diff(old_names, new_names);
 
    logger->info("Server '{}' tools refreshed: +{} -{}",
                 name_, added.size(), removed.size());
    return {added, removed};
}
 
bool ExternalMCPClient::is_connected() const {
    return transport_->is_connected();
}
 
std::string ExternalMCPClient::build_request(
    const std::string& method,
    const std::string& params) {
    int ignored = 0;
    return build_request_id(method, params, ignored);
}
 
std::string ExternalMCPClient::build_request_id(
    const std::string& method,
    const std::string& params,
    int& id) {
 
    id = next_id_.fetch_add(1, std::memory_order_relaxed);
    nlohmann::json req;
    req["jsonrpc"] = "2.0";
    req["id"] = id;
    req["method"] = method;
    try {
        req["params"] = nlohmann::json::parse(params);
    } catch (...) {
        req["params"] = nlohmann::json::object();
    }
    return req.dump();
}
 
bool ExternalMCPClient::response_matches(
    const std::string& response_json, int expected_id) {
    try {
        auto j = nlohmann::json::parse(response_json);
        // A string id is accepted when it spells the same number. We always
        // SEND an integer and JSON-RPC 2.0 requires the response to echo the
        // same value, but stringifying it is the one deviation common enough
        // in the wild to be worth tolerating — it is unambiguous, so
        // rejecting it would break working servers for no safety gain.
        if (j.value("id", nlohmann::json()).is_string()) {
            return j["id"].get<std::string>()
                == std::to_string(expected_id);
        }
        return j.contains("id") && j["id"].is_number_integer()
            && j["id"].get<int>() == expected_id;
    } catch (const nlohmann::json::exception&) {
        return false;
    }
}
 
bool ExternalMCPClient::validate_init_response(
    const std::string& response) {
 
    try {
        auto j = nlohmann::json::parse(response);
        if (j.contains("error")) {
            logger->error("Initialize error from '{}': {}",
                          name_, j["error"].dump());
            return false;
        }
        return true;
    } catch (...) {
        return false;
    }
}
 
bool ExternalMCPClient::send_initialize() {
    nlohmann::json params;
    params["protocolVersion"] = "2024-11-05";
    params["capabilities"] = nlohmann::json::object();
    params["clientInfo"]["name"] = "entropic";
    params["clientInfo"]["version"] = "1.8.7";
 
    int request_id = 0;
    auto request = build_request_id(
        "initialize", params.dump(), request_id);
    auto response = transport_->send_request(
        request, init_timeout_ms_);
 
    if (response.empty() || !response_matches(response, request_id)) {
        return false;
    }
    return validate_init_response(response);
}
 
bool ExternalMCPClient::query_tools() {
    int request_id = 0;
    auto request = build_request_id("tools/list", "{}", request_id);
    auto response = transport_->send_request(
        request, init_timeout_ms_);
 
    if (response.empty() || !response_matches(response, request_id)) {
        return false;
    }
 
    try {
        auto j = nlohmann::json::parse(response);
        auto tools = j.at("result").at("tools");
 
        // Prefix tool names with server name
        std::vector<std::string> names;
        for (auto& tool : tools) {
            std::string orig = tool["name"].get<std::string>();
            tool["name"] = name_ + "." + orig;
            names.push_back(tool["name"].get<std::string>());
        }
 
        std::lock_guard<std::mutex> lock(tools_mutex_);
        cached_tools_json_ = tools.dump();
        cached_tool_names_ = std::move(names);
        return true;
    } catch (const nlohmann::json::exception& e) {
        logger->error("Failed to parse tools/list from '{}': {}",
                      name_, e.what());
        return false;
    }
}
 
std::string ExternalMCPClient::extract_tool_result(
    const std::string& response_json) {
    std::string text;
    try {
        auto j = nlohmann::json::parse(response_json);
        if (j.contains("error")) {
            return "Error: " + j["error"]["message"].get<std::string>();
        }
        const auto& result = j.at("result");
        for (const auto& item : result.at("content")) {
            if (item.value("type", "") == "text") {
                text += item.at("text").get<std::string>();
            }
        }
        if (result.value("isError", false)) { text = "Error: " + text; }
    } catch (const nlohmann::json::exception& e) {
        text = "Error parsing response: " + std::string(e.what());
    }
    return text;
}
 
std::string ExternalMCPClient::build_response(
    const std::string& result_text,
    bool is_error) {
 
    nlohmann::json resp;
    resp["result"] = result_text;
    // SECURITY: External servers CANNOT inject directives.
    // Directives array is always empty for external tool results.
    resp["directives"] = nlohmann::json::array();
    if (is_error) {
        resp["is_error"] = true;
    }
    return resp.dump();
}
 
void ExternalMCPClient::set_init_timeout_ms(uint32_t ms) {
    if (ms > 0) { init_timeout_ms_ = ms; }
}
 
} // namespace entropic