roots.hpp

Go to the documentation of this file.

// Copyright (c) 2025 [caomengxuan666]
 
#pragma once
 
 
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
#include "cxxmcp/core/result.hpp"
#include "cxxmcp/protocol/reflect.hpp"
#include "cxxmcp/protocol/types.hpp"
 
namespace mcp::protocol {
 
struct Root {
  std::string uri;
  std::optional<std::string> name;
  std::optional<Json> meta;
  Json extensions = Json::object();
};
 
template <>
struct Reflect<Root> {
  static constexpr bool defined = true;
  static auto fields() {
    return std::make_tuple(
        field("uri", &Root::uri), field("name", &Root::name),
        field("_meta", &Root::meta),
        extensions_field(&Root::extensions, {"uri", "name", "_meta"}));
  }
  static std::vector<std::string> known_keys() {
    return {"uri", "name", "_meta"};
  }
};
 
struct RootsListResult {
  std::vector<Root> roots;
  std::optional<Json> meta;
  Json extensions = Json::object();
};
 
inline core::Error roots_json_error(std::string message) {
  return core::Error{
      static_cast<int>(ErrorCode::InvalidRequest), std::move(message), {}};
}
 
inline Json root_to_json(const Root& root) { return reflect_to_json(root); }
 
inline core::Result<Root> root_from_json(const Json& json) {
  return reflect_from_json<Root>(json);
}
 
inline Json roots_list_result_to_json(const RootsListResult& result) {
  Json json = Json::object();
  json["roots"] = Json::array();
  for (const auto& root : result.roots) {
    json["roots"].push_back(root_to_json(root));
  }
  if (result.meta.has_value()) {
    json["_meta"] = *result.meta;
  }
  append_json_extensions(json, result.extensions);
  return json;
}
 
inline core::Result<RootsListResult> roots_list_result_from_json(
    const Json& json) {
  if (!json.is_object()) {
    return mcp::core::unexpected(
        roots_json_error("roots/list result must be an object"));
  }
  if (!json.contains("roots") || !json.at("roots").is_array()) {
    return mcp::core::unexpected(
        roots_json_error("roots/list result requires a roots array"));
  }
 
  RootsListResult result;
  for (const auto& item : json.at("roots")) {
    const auto root = root_from_json(item);
    if (!root) {
      return mcp::core::unexpected(root.error());
    }
    result.roots.push_back(*root);
  }
  if (json.contains("_meta")) {
    if (!json.at("_meta").is_object()) {
      return mcp::core::unexpected(
          roots_json_error("roots/list result _meta must be an object"));
    }
    result.meta = json.at("_meta");
  }
  result.extensions = collect_json_extensions(json, {"roots", "_meta"});
  return result;
}
 
}  // namespace mcp::protocol