* Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
*/
#ifndef MCP_HTTP_COMMON_INCLUDE_H_
#define MCP_HTTP_COMMON_INCLUDE_H_
#include <cstddef>
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
#include <variant>
namespace Mcp {
using RequestId = std::variant<int64_t, std::string>;
}
namespace Mcp::Http {
using Mcp::RequestId;
constexpr const char* MCP_SESSION_ID_HEADER = "mcp-session-id";
constexpr const char* MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
constexpr const char* CONTENT_TYPE_HEADER = "content-type";
constexpr const char* ACCEPT_HEADER = "accept";
constexpr const char* CACHE_CONTROL_HEADER = "cache-control";
constexpr const char* CONNECTION_HEADER = "connection";
constexpr const char* HOST_HEADER = "host";
constexpr const char* CONTENT_LENGTH_HEADER = "content-length";
constexpr const char* TRANSFER_ENCODING_HEADER = "transfer-encoding";
constexpr const char* X_ACCEL_BUFFERING_HEADER = "x-accel-buffering";
constexpr const char* AUTHORIZATION_HEADER = "authorization";
constexpr const char* CONTENT_TYPE_JSON = "application/json";
constexpr const char* CONTENT_TYPE_SSE = "text/event-stream";
constexpr const char* CONTENT_TYPE_TEXT_PLAIN = "text/plain";
constexpr const char* CACHE_CONTROL_NO_CACHE_NO_TRANSFORM = "no-cache, no-transform";
constexpr const char* CONNECTION_KEEP_ALIVE = "keep-alive";
constexpr const char* CONNECTION_CLOSE = "close";
constexpr const char* TRANSFER_ENCODING_CHUNKED = "chunked";
constexpr int HTTP_STATUS_OK = 200;
constexpr int HTTP_STATUS_ACCEPTED = 202;
constexpr int HTTP_STATUS_NO_CONTENT = 204;
constexpr int HTTP_STATUS_BAD_REQUEST = 400;
constexpr int HTTP_STATUS_UNAUTHORIZED = 401;
constexpr int HTTP_STATUS_FORBIDDEN = 403;
constexpr int HTTP_STATUS_NOT_FOUND = 404;
constexpr int HTTP_STATUS_METHOD_NOT_ALLOWED = 405;
constexpr int HTTP_STATUS_NOT_ACCEPTABLE = 406;
constexpr int HTTP_STATUS_CONFLICT = 409;
constexpr int HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415;
constexpr int HTTP_STATUS_INTERNAL_SERVER_ERROR = 500;
constexpr int HTTP_STATUS_SERVICE_UNAVAILABLE = 503;
constexpr int HTTP_PARSE_OK = 0;
constexpr int HTTP_PARSE_NEED_MORE = 1;
constexpr int HTTP_PARSE_ERROR = -1;
constexpr int HTTP_CLIENT_DEFAULT_TIMEOUT_MS = 5000;
constexpr std::size_t HTTP_HEADER_BODY_SEPARATOR_LENGTH = 4;
constexpr size_t SSE_EVENT_PREFIX_LEN = sizeof("event:") - 1;
constexpr size_t SSE_ID_PREFIX_LEN = sizeof("id:") - 1;
constexpr size_t SSE_DATA_PREFIX_LEN = sizeof("data:") - 1;
struct ServerSentEvent {
std::string event;
std::string id;
std::string data;
int retry;
ServerSentEvent() : event("message"), id(""), data(""), retry(0)
{
}
ServerSentEvent(const std::string& evt, const std::string& evtId, const std::string& evtData, int retry)
: event(evt), id(evtId), data(evtData), retry(retry)
{
}
};
struct UserData {
RequestId requestId = int64_t(0);
std::string method;
};
enum class HttpSendType {
HTTPRESPONSE = 0,
HTTPRESPONSESTART,
HTTPRESPONSEBODY,
};
struct HttpRequest {
std::string method;
std::string url;
std::string version;
std::unordered_map<std::string, std::string> headers;
std::string body;
std::unordered_map<std::string, std::string> queryParams;
std::unordered_map<std::string, std::string> pathParams;
};
struct HttpResponse {
bool success = false;
UserData userData;
int statusCode = 0;
std::string errorMessage;
std::string statusText;
ServerSentEvent sseEvent;
HttpSendType type = HttpSendType::HTTPRESPONSE;
std::unordered_map<std::string, std::string> headers;
std::string body;
HttpResponse() : statusCode(HTTP_STATUS_OK), statusText("OK")
{
headers[CONNECTION_HEADER] = CONNECTION_KEEP_ALIVE;
}
};
using HttpCallback = std::function<bool(const HttpResponse& response)>;
enum class HttpServerStartResult {
OK = 0,
ALREADY_RUNNING,
EVENT_SYSTEM_INIT_FAILED,
SSL_CONTEXT_INIT_FAILED,
LISTEN_FAILED,
START_LISTENER_FAILED,
};
void TrimInPlace(std::string& value);
bool ParseHeadersAndBody(const std::string& buffer, std::size_t headerEnd,
std::unordered_map<std::string, std::string>& headers, std::string& body,
std::size_t& consumedBytes);
std::string getContentType(const HttpResponse& response);
bool parseSseLine(const std::string& line, ServerSentEvent& sseEvent);
* @brief Validate Streamable HTTP endpoint URL used by MCP Client/Server create APIs.
*
* Requires http/https scheme and a non-empty host. Port is optional; when present it must be in [1, 65535].
* Optional path/query is allowed. Rejects fragments ('#'), empty values, spaces, oversized URLs, and malformed hosts.
*
* @param endpoint Endpoint URL string to validate.
* @param errorMsg Optional output for a human-readable failure reason.
* @return true if the endpoint is valid; false otherwise.
*/
bool IsValidStreamableHttpEndpoint(const std::string& endpoint, std::string* errorMsg = nullptr);
}
#endif