types.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/types.h>
 
#include <algorithm>
#include <array>
#include <chrono>
#include <cstddef>
#include <filesystem>
#include <functional>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace neograph::mcp {
 
inline constexpr std::array<std::string_view, 4> MCP_SUPPORTED_PROTOCOL_VERSIONS = {
    "2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"};
 
inline bool is_supported_protocol_version(std::string_view version) noexcept {
    return std::find(MCP_SUPPORTED_PROTOCOL_VERSIONS.begin(),
                     MCP_SUPPORTED_PROTOCOL_VERSIONS.end(),
                     version) != MCP_SUPPORTED_PROTOCOL_VERSIONS.end();
}
 
using HeaderList = std::vector<std::pair<std::string, std::string>>;
using HeaderProvider = std::function<HeaderList()>;
 
struct NEOGRAPH_API MCPClientConfig {
    std::chrono::milliseconds request_timeout{std::chrono::seconds(30)};
    HeaderList                headers;
    HeaderProvider            header_provider;
};
 
struct NEOGRAPH_API StdioClientConfig {
    std::vector<std::string> argv;
    std::filesystem::path cwd;
    std::vector<std::pair<std::string, std::string>> environment;
    bool replace_environment = false;
    std::size_t max_frame_bytes = 16 * 1024 * 1024;
    std::size_t max_stdout_text_lines = 1000;
    std::size_t max_stdout_text_bytes = 256 * 1024;
    std::size_t max_stderr_bytes = 64 * 1024;
    std::chrono::milliseconds startup_timeout{10000};
    std::chrono::milliseconds request_timeout{30000};
    std::chrono::milliseconds cancel_grace{500};
};
 
class NEOGRAPH_API MCPError : public std::runtime_error {
  public:
    MCPError(int code, std::string message, json data = nullptr, int http_status = 0);
 
    int         code() const noexcept { return code_; }
    const json& data() const noexcept { return data_; }
    int         http_status() const noexcept { return http_status_; }
 
  private:
    int  code_;
    json data_;
    int  http_status_ = 0;
};
enum class MCPFailure {
    connection, timeout, cancelled, shutdown, http_status, protocol
};
 
class NEOGRAPH_API MCPTransportError : public std::runtime_error {
  public:
    MCPTransportError(MCPFailure failure, std::string message, int http_status = 0);
    MCPFailure failure() const noexcept { return failure_; }
    int http_status() const noexcept { return http_status_; }
 
  private:
    MCPFailure failure_;
    int http_status_;
};
 
 
struct NEOGRAPH_API InitializeResult {
    std::string protocol_version;
    json        capabilities = json::object();
    json        server_info = json::object();
    std::string instructions;
    json        raw = json::object();
 
    static InitializeResult from_json(const json& value);
};
 
struct NEOGRAPH_API ToolDefinition {
    std::string name;
    std::string title;
    std::string description;
    json        icons = json::array();
    json        input_schema = json{{"type", "object"}};
    json        output_schema;
    json        annotations = json::object();
    json        execution = json::object();
    json        meta = json::object();
    json        raw = json::object();
 
    static ToolDefinition from_json(const json& value);
    json to_json() const;
};
 
struct NEOGRAPH_API ListToolsPage {
    std::vector<ToolDefinition> tools;
    std::optional<std::string>  next_cursor;
    json                        meta = json::object();
    json                        raw = json::object();
 
    static ListToolsPage from_json(const json& value);
};
 
struct NEOGRAPH_API CallToolResult {
    json content = json::array();
    json structured_content;
    bool is_error = false;
    json meta = json::object();
    json raw = json::object();
 
    static CallToolResult from_json(const json& value);
    json to_json() const;
};
 
} // namespace neograph::mcp