mcp.h

#ifndef SOURCEMETA_CORE_MCP_H_
#define SOURCEMETA_CORE_MCP_H_
 
#ifndef SOURCEMETA_CORE_MCP_EXPORT
#include <sourcemeta/core/mcp_export.h>
#endif
 
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/jsonrpc.h>
 
#include <cstddef>  // std::size_t
#include <cstdint>  // std::int64_t, std::uint8_t
#include <optional> // std::optional, std::nullopt
#include <utility>  // std::unreachable

 
namespace sourcemeta::core {

enum class MCPProtocolVersion : std::uint8_t {
  V_2025_03_26,
  V_2025_06_18,
  V_2025_11_25,
};

constexpr auto
mcp_protocol_version_string(const MCPProtocolVersion version) noexcept
    -> JSON::StringView {
  switch (version) {
    case MCPProtocolVersion::V_2025_03_26:
      return "2025-03-26";
    case MCPProtocolVersion::V_2025_06_18:
      return "2025-06-18";
    case MCPProtocolVersion::V_2025_11_25:
      return "2025-11-25";
  }
  std::unreachable();
}

constexpr JSON::StringView MCP_METHOD_INITIALIZE{"initialize"};

constexpr JSON::StringView MCP_METHOD_PING{"ping"};

constexpr JSON::StringView MCP_METHOD_TOOLS_LIST{"tools/list"};

constexpr JSON::StringView MCP_METHOD_TOOLS_CALL{"tools/call"};

constexpr JSON::StringView MCP_METHOD_RESOURCES_LIST{"resources/list"};

constexpr JSON::StringView MCP_METHOD_RESOURCES_READ{"resources/read"};

constexpr JSON::StringView MCP_METHOD_RESOURCES_TEMPLATES_LIST{
    "resources/templates/list"};

constexpr JSON::StringView MCP_METHOD_NOTIFICATIONS_INITIALIZED{
    "notifications/initialized"};

constexpr std::int64_t MCP_CODE_RESOURCE_NOT_FOUND{-32002};

constexpr std::int64_t MCP_CODE_URL_ELICITATION_REQUIRED{-32042};

constexpr auto mcp_is_request_method(const JSON::StringView method) noexcept
    -> bool {
  return method == MCP_METHOD_INITIALIZE || method == MCP_METHOD_PING ||
         method == MCP_METHOD_TOOLS_LIST || method == MCP_METHOD_TOOLS_CALL ||
         method == MCP_METHOD_RESOURCES_LIST ||
         method == MCP_METHOD_RESOURCES_READ ||
         method == MCP_METHOD_RESOURCES_TEMPLATES_LIST;
}

constexpr auto
mcp_resolve_protocol_version(const JSON::StringView header) noexcept
    -> std::optional<MCPProtocolVersion> {
  if (header.empty()) {
    // Per the MCP Streamable HTTP transport spec: if the server does not
    // receive an MCP-Protocol-Version header, and has no other way to identify
    // the version, the server SHOULD assume protocol version 2025-03-26.
    // https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#protocol-version-header
    return MCPProtocolVersion::V_2025_03_26;
  }
  if (header == "2025-11-25") {
    return MCPProtocolVersion::V_2025_11_25;
  }
  if (header == "2025-06-18") {
    return MCPProtocolVersion::V_2025_06_18;
  }
  if (header == "2025-03-26") {
    return MCPProtocolVersion::V_2025_03_26;
  }
  return std::nullopt;
}

constexpr auto
mcp_supports_output_schema(const MCPProtocolVersion version) noexcept -> bool {
  return version != MCPProtocolVersion::V_2025_03_26;
}

constexpr auto
mcp_supports_structured_content(const MCPProtocolVersion version) noexcept
    -> bool {
  return version != MCPProtocolVersion::V_2025_03_26;
}

constexpr auto
mcp_supports_resource_link_content(const MCPProtocolVersion version) noexcept
    -> bool {
  return version != MCPProtocolVersion::V_2025_03_26;
}

constexpr auto
mcp_supports_implementation_title(const MCPProtocolVersion version) noexcept
    -> bool {
  return version != MCPProtocolVersion::V_2025_03_26;
}

constexpr auto mcp_supports_implementation_description(
    const MCPProtocolVersion version) noexcept -> bool {
  return version == MCPProtocolVersion::V_2025_11_25;
}

constexpr auto mcp_supports_implementation_website_url(
    const MCPProtocolVersion version) noexcept -> bool {
  return version == MCPProtocolVersion::V_2025_11_25;
}

constexpr auto
mcp_supports_jsonrpc_batching(const MCPProtocolVersion version) noexcept
    -> bool {
  return version == MCPProtocolVersion::V_2025_03_26;
}

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_text_block(const JSON::StringView text) -> sourcemeta::core::JSON;

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_resource_link(const MCPProtocolVersion version,
                            const JSON::StringView uri,
                            const JSON::StringView mime_type,
                            const JSON::StringView name = {},
                            const JSON::StringView description = {})
    -> sourcemeta::core::JSON;

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_tool_success(const MCPProtocolVersion version,
                           const sourcemeta::core::JSON &identifier,
                           sourcemeta::core::JSON result)
    -> sourcemeta::core::JSON;

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_tool_success(const MCPProtocolVersion version,
                           const sourcemeta::core::JSON &identifier,
                           sourcemeta::core::JSON structured,
                           sourcemeta::core::JSON content_blocks)
    -> sourcemeta::core::JSON;

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_tool_error(const sourcemeta::core::JSON &identifier,
                         const JSON::StringView message)
    -> sourcemeta::core::JSON;

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_error_resource_not_found(const sourcemeta::core::JSON &identifier)
    -> sourcemeta::core::JSON;

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_resource(const JSON::StringView uri, const JSON::StringView name,
                       const JSON::StringView mime_type,
                       const JSON::StringView description = {},
                       const std::optional<std::size_t> size = std::nullopt,
                       const std::optional<double> priority = std::nullopt)
    -> sourcemeta::core::JSON;

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_resource_text_content(const JSON::StringView uri,
                                    const JSON::StringView mime_type,
                                    const JSON::StringView text)
    -> sourcemeta::core::JSON;

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_resources_read_result(sourcemeta::core::JSON contents)
    -> sourcemeta::core::JSON;

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_resource_template(const JSON::StringView uri_template,
                                const JSON::StringView name,
                                const JSON::StringView description,
                                const JSON::StringView mime_type)
    -> sourcemeta::core::JSON;

struct MCPToolAnnotations {
  JSON::StringView title = {};
  bool read_only = false;
  bool destructive = true;
  bool idempotent = false;
  bool open_world = true;
};

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_tool_descriptor(
    const MCPProtocolVersion version, const JSON::StringView name,
    const JSON::StringView description, sourcemeta::core::JSON input_schema,
    std::optional<sourcemeta::core::JSON> output_schema = std::nullopt,
    const MCPToolAnnotations &annotations = {}) -> sourcemeta::core::JSON;

struct MCPImplementation {
  JSON::StringView name;
  JSON::StringView version;
  JSON::StringView title = {};
  JSON::StringView description = {};
  JSON::StringView website_url = {};
};

struct MCPServerCapabilities {
  bool prompts = false;
  bool resources = false;
  bool tools = false;
  bool logging = false;
  bool completions = false;
};

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_make_initialize_result(const sourcemeta::core::JSON &request,
                                const MCPServerCapabilities &capabilities,
                                const MCPImplementation &server,
                                const JSON::StringView instructions = {})
    -> sourcemeta::core::JSON;

SOURCEMETA_CORE_MCP_EXPORT
auto mcp_tool_call_arguments(const sourcemeta::core::JSON &envelope)
    -> const sourcemeta::core::JSON *;
 
} // namespace sourcemeta::core
 
#endif