server_base.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/mcp/server_base.h>
#include <entropic/types/logging.h>
 
#include <nlohmann/json.hpp>
 
#include <exception>
 
static auto logger = entropic::log::get("mcp.server_base");
 
namespace entropic {
 
MCPServerBase::MCPServerBase(std::string name)
    : name_(std::move(name)) {}
 
const std::string& MCPServerBase::name() const {
    return name_;
}
 
void MCPServerBase::register_tool(ToolBase* tool) {
    registry_.register_tool(tool);
}
 
std::string MCPServerBase::list_tools() const {
    return registry_.get_tools_json();
}
 
std::string MCPServerBase::normalize_args(
    const std::string& tool_name,
    const std::string& raw) const {
    const auto first = raw.find_first_not_of(" \t\r\n");
    if (first == std::string::npos) {
        return "{}";
    }
    // Non-throwing parse: a discarded value is unparseable and is left
    // alone on purpose, as is any non-null non-object.
    const auto parsed = nlohmann::json::parse(raw, nullptr, false);
    if (!parsed.is_null()) {
        return raw;
    }
    logger->info(
        "[{}.{}] arguments arrived as JSON null — reading as \"no "
        "arguments\" and dispatching with {{}}",
        name_, tool_name);
    return "{}";
}
 
std::string MCPServerBase::execute(
    const std::string& tool_name,
    const std::string& raw_args_json) {
    logger->info("[EXECUTE] {}.{}", name_, tool_name);
 
    const std::string args_json = normalize_args(tool_name, raw_args_json);
 
    ServerResponse response;
    try {
        response = registry_.dispatch(tool_name, args_json);
 
        auto* tool = registry_.get_tool(tool_name);
        if (tool != nullptr) {
            inject_anchor_if_needed(*tool, args_json, response);
        }
    } catch (const std::exception& e) {
        // Full args are logged, never truncated — for this failure class
        // the arguments are the whole diagnosis.
        logger->error("Tool '{}.{}' threw: {} — args: {}",
                      name_, tool_name, e.what(), args_json);
        response.directives.clear();
        response.result =
            "Error: tool '" + name_ + "." + tool_name + "' failed: "
            + e.what();
    }
 
    return serialize_response(response);
}
 
std::string MCPServerBase::get_permission_pattern(
    const std::string& tool_name,
    const std::string& /*args_json*/) const {
    return tool_name;
}
 
bool MCPServerBase::skip_duplicate_check(
    const std::string& /*tool_name*/) const {
    return false;
}
 
bool MCPServerBase::configure(const std::string& /*config_json*/) {
    return true;
}
 
bool MCPServerBase::set_working_dir(const std::string& /*path*/) {
    return true;
}
 
static const char* const DIRECTIVE_NAMES[] = {
    "stop_processing",   // 0
    "tier_change",       // 1
    "delegate",          // 2
    "pipeline",          // 3
    "complete",          // 4
    "clear_self_todos",  // 5
    "inject_context",    // 6
    "prune_messages",    // 7
    "context_anchor",    // 8
    "phase_change",      // 9
    "notify_presenter",  // 10
};
 
static const char* directive_type_name(
    entropic_directive_type_t type) {
    auto idx = static_cast<int>(type);
    constexpr int count = sizeof(DIRECTIVE_NAMES)
                        / sizeof(DIRECTIVE_NAMES[0]);
    if (idx < 0 || idx >= count) {
        return "unknown";
    }
    return DIRECTIVE_NAMES[idx];
}
 
std::string MCPServerBase::serialize_response(
    const ServerResponse& response) {
    nlohmann::json j;
    j["result"] = response.result;
 
    auto directives = nlohmann::json::array();
    for (const auto& d : response.directives) {
        nlohmann::json dj;
        dj["type"] = directive_type_name(d.type);
        directives.push_back(std::move(dj));
    }
    j["directives"] = std::move(directives);
 
    return j.dump();
}
 
void MCPServerBase::inject_anchor_if_needed(
    const ToolBase& tool,
    const std::string& args_json,
    ServerResponse& response) {
    auto key = tool.anchor_key(args_json);
    if (key.empty()) {
        return;
    }
    Directive anchor;
    anchor.type = ENTROPIC_DIRECTIVE_CONTEXT_ANCHOR;
    response.directives.push_back(std::move(anchor));
    logger->info("Auto-injected ContextAnchor: {}", key);
}
 
} // namespace entropic