entropic_mcp.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include "engine_handle.h"
 
#include <entropic/entropic.h>
#include <entropic/mcp/mcp_json_discovery.h>
#include <entropic/types/logging.h>
 
#include "json_serializers.h"
 
#include <cstring>
 
static auto logger = entropic::log::get("facade.mcp");
 
static entropic_error_t check_server_mgr(entropic_handle_t h) {
    if (!h) { return ENTROPIC_ERROR_INVALID_HANDLE; }
    if (!h->server_manager) { return ENTROPIC_ERROR_INVALID_STATE; }
    return ENTROPIC_OK;
}
 
static entropic::ExternalServerConfig parse_external_server_spec(
    const char* name, const nlohmann::json& j) {
    entropic::ExternalServerConfig spec;
    spec.name = name;
    spec.command = j.value("command", "");
    spec.url = j.value("url", "");
    spec.transport = j.value("transport",
        spec.url.empty() ? "stdio" : "sse");
    if (j.contains("args") && j["args"].is_array()) {
        spec.args = j["args"].get<std::vector<std::string>>();
    }
    if (j.contains("env") && j["env"].is_object()) {
        for (auto& [key, val] : j["env"].items()) {
            if (entropic::is_blocked_env_var(key)) {
                logger->warn("register_mcp_server '{}': blocked env var "
                             "'{}' — skipping", name, key);
                continue;
            }
            if (val.is_string()) {
                spec.env[key] = val.get<std::string>();
            }
        }
    }
    return spec;
}
 
extern "C" ENTROPIC_EXPORT entropic_error_t
entropic_register_mcp_server(
    entropic_handle_t handle,
    const char* name,
    const char* config_json) {
 
    auto rc = check_server_mgr(handle);
    if (rc != ENTROPIC_OK || !name || !config_json) {
        return rc != ENTROPIC_OK ? rc : ENTROPIC_ERROR_INVALID_ARGUMENT;
    }
 
    try {
        auto j = nlohmann::json::parse(config_json);
        auto spec = parse_external_server_spec(name, j);
        handle->server_manager->connect_external_server(spec);
        logger->info("register_mcp_server: name='{}' env_keys={}",
                     name, spec.env.size());
        return ENTROPIC_OK;
    } catch (const std::exception& e) {
        handle->last_error = e.what();
        return ENTROPIC_ERROR_CONNECTION_FAILED;
    }
}
 
extern "C" ENTROPIC_EXPORT entropic_error_t
entropic_deregister_mcp_server(
    entropic_handle_t handle,
    const char* name) {
 
    auto rc = check_server_mgr(handle);
    if (rc != ENTROPIC_OK || !name) {
        return rc != ENTROPIC_OK ? rc : ENTROPIC_ERROR_INVALID_ARGUMENT;
    }
 
    try {
        handle->server_manager->disconnect_external_server(name);
        logger->info("deregister_mcp_server: name='{}'", name);
        return ENTROPIC_OK;
    } catch (const std::exception& e) {
        handle->last_error = e.what();
        return ENTROPIC_ERROR_SERVER_NOT_FOUND;
    }
}
 
extern "C" ENTROPIC_EXPORT char*
entropic_list_mcp_servers(entropic_handle_t handle) {
    if (!handle || !handle->configured.load()) {
        return nullptr;
    }
    try {
        nlohmann::json arr = nlohmann::json::array();
        if (handle->server_manager) {
            auto servers = handle->server_manager->list_server_info();
            for (const auto& [name, s] : servers) {
                arr.push_back({{"name", s.name},
                               {"transport", s.transport},
                               {"status", s.status},
                               {"source", s.source}});
            }
        }
        return strdup(arr.dump().c_str());
    } catch (const std::exception& e) {
        handle->last_error = e.what();
        return nullptr;
    }
}