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>
 
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::execute(
    const std::string& tool_name,
    const std::string& args_json) {
    logger->info("[EXECUTE] {}.{}", name_, tool_name);
 
    auto 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);
    }
 
    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