tool_base.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/mcp/tool_base.h>
#include <entropic/mcp/server_base.h>
#include <entropic/types/logging.h>
 
#include <nlohmann/json.hpp>
 
#include <algorithm>
#include <fstream>
#include <stdexcept>
#include <string>
#include <vector>
 
static auto logger = entropic::log::get("mcp.tool_base");
 
namespace entropic {
 
ToolBase::ToolBase(ToolDefinition def)
    : definition_(std::move(def)) {}
 
const std::string& ToolBase::name() const {
    return definition_.name;
}
 
const ToolDefinition& ToolBase::definition() const {
    return definition_;
}
 
std::string ToolBase::anchor_key(
    const std::string& /*args_json*/) const {
    return "";
}
 
MCPAccessLevel ToolBase::required_access_level() const {
    return MCPAccessLevel::WRITE;
}
 
namespace {
 
using ojson = nlohmann::ordered_json;
 
std::string render_shape(const ojson& schema);
 
std::string render_type(const ojson& type) {
    if (!type.is_array()) { return type.get<std::string>(); }
    std::string out;
    for (const auto& t : type) {
        out += (out.empty() ? "" : "|") + t.get<std::string>();
    }
    return out;
}
 
std::string render_alternatives(const ojson& alts, bool literal) {
    std::string out;
    for (const auto& a : alts) {
        out += (out.empty() ? "" : " | ")
            + (literal ? a.dump() : render_shape(a));
    }
    return out;
}
 
std::string render_object(const ojson& schema) {
    const auto required = schema.value("required", ojson::array());
    const auto props = schema.value("properties", ojson::object());
    std::string out = "{";
    for (const auto& [key, prop] : props.items()) {
        bool req = std::find(required.begin(), required.end(), key) != required.end();
        out += (out.size() > 1 ? ", " : "") + ojson(key).dump()
            + (req ? "" : "?") + ": " + render_shape(prop);
    }
    const auto extra = schema.value("additionalProperties", ojson(false));
    if (extra.is_object()) {
        out += (out.size() > 1 ? ", " : "") + std::string("<string>: ")
            + render_shape(extra);
    }
    return out + "}";
}
 
std::string render_typed(const ojson& schema) {
    const auto type = schema.value("type", ojson());
    std::string out = "any";
    if (type == "object") {
        out = render_object(schema);
    } else if (type == "array") {
        out = "[" + render_shape(schema.value("items", ojson::object())) + ", ...]";
    } else if (!type.is_null()) {
        out = render_type(type);
    }
    return out;
}
 
std::string render_shape(const ojson& schema) {
    std::string out;
    if (schema.contains("enum")) {
        out = render_alternatives(schema["enum"], true);
    } else if (schema.contains("oneOf")) {
        out = render_alternatives(schema["oneOf"], false);
    } else {
        out = render_typed(schema);
    }
    return out;
}
 
void collect_notes(const ojson& schema, std::vector<std::string>& notes) {
    const auto props = schema.value("properties", ojson::object());
    for (const auto& [key, prop] : props.items()) {
        if (prop.contains("description")) {
            notes.push_back("- `" + key + "`: " + prop["description"].get<std::string>());
        }
        collect_notes(prop, notes);
    }
    if (schema.contains("items")) { collect_notes(schema["items"], notes); }
    const auto branches = schema.value("oneOf", ojson::array());
    for (const auto& branch : branches) {
        collect_notes(branch, notes);
    }
}
 
std::string render_variants(const ojson& schema) {
    std::string out;
    if (!schema.contains("oneOf")) {
        return render_shape(schema) + "\n";
    }
    int n = 0;
    for (const auto& branch : schema["oneOf"]) {
        ++n;
        out += "- " + branch.value("title", "variant " + std::to_string(n))
            + ": " + render_shape(branch) + "\n";
    }
    return out;
}
 
}  // namespace
 
std::string render_response_format(const std::string& output_schema_json) {
    auto schema = ojson::parse(output_schema_json, nullptr, false);
    std::string out;
    if (schema.is_object()) {
        out = "\n\n**Response format** (JSON):\n" + render_variants(schema);
        std::vector<std::string> notes;
        collect_notes(schema, notes);
        for (const auto& note : notes) { out += note + "\n"; }
        // Engine-wide, not per tool: a call refused before or thrown out of
        // the handler (bad arguments, a refused path, an I/O fault) is
        // reported by the server base as plain text (server_base.cpp).
        out += "Other failures: plain text `Error: ...`.\n";
    }
    return out;
}
 
std::string tool_error_json(const std::string& code, const std::string& message) {
    nlohmann::json err;
    err["error"] = code;
    err["message"] = message;
    return err.dump();
}
 
ToolDefinition load_tool_definition(
    const std::string& tool_name,
    const std::string& server_prefix,
    const std::string& data_dir) {
 
    std::string path = data_dir;
    if (!server_prefix.empty()) {
        path += "/" + server_prefix;
    }
    path += "/" + tool_name + ".json";
 
    std::ifstream file(path);
    if (!file.is_open()) {
        throw std::runtime_error(
            "Tool definition not found: " + path);
    }
 
    // ordered: the rendered Response format keeps the authored key order.
    auto json = nlohmann::ordered_json::parse(file);
 
    ToolDefinition def;
    def.name = json.at("name").get<std::string>();
    def.description = json.value("description", "");
    def.input_schema = json.at("inputSchema").dump();
    if (json.contains("outputSchema")) {
        def.output_schema = json["outputSchema"].dump();
        def.description += render_response_format(def.output_schema);
    }
 
    logger->info("Loaded tool definition: {} from {}",
                 def.name, path);
    return def;
}
 
} // namespace entropic