transport.hpp

Go to the documentation of this file.

// Copyright (c) 2025 [caomengxuan666]
 
#pragma once
 
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
 
#include "cxxmcp/core/result.hpp"
#include "cxxmcp/protocol/capabilities.hpp"
#include "cxxmcp/protocol/serialization.hpp"
#include "cxxmcp/protocol/types.hpp"
#include "cxxmcp/server/auth.hpp"
 
 
namespace mcp::server {
 
class Transport;
class ClientPeer;
using SessionClient = ClientPeer;
using ClientHandle = ClientPeer;
 
struct SessionContext {
  std::string session_id;
  std::string remote_address;
  std::unordered_map<std::string, std::string> headers;
  std::optional<std::string> http_method;
  std::optional<std::string> http_url;
  std::optional<AuthIdentity> auth_identity;
  Transport* transport = nullptr;
  std::weak_ptr<void> transport_lifetime;
 
  SessionClient client() const noexcept;
};
 
using RequestHandler = std::function<core::Result<protocol::JsonRpcResponse>(
    const protocol::JsonRpcRequest&, const SessionContext&)>;
 
inline std::string_view request_wire_version(
    const protocol::JsonRpcRequest& request,
    const SessionContext& context) noexcept {
  if (request.meta.has_value() && request.meta->is_object() &&
      request.meta->contains("io.modelcontextprotocol/protocolVersion") &&
      request.meta->at("io.modelcontextprotocol/protocolVersion").is_string()) {
    return request.meta->at("io.modelcontextprotocol/protocolVersion")
        .get_ref<const std::string&>();
  }
  if (request.protocol_version_override.has_value()) {
    return *request.protocol_version_override;
  }
  for (const auto& [name, value] : context.headers) {
    if (name.size() == 20) {
      char lower[21];
      for (std::size_t i = 0; i < name.size(); ++i) {
        const char c = name[i];
        lower[i] = static_cast<char>(c >= 'A' && c <= 'Z' ? c - 'A' + 'a' : c);
      }
      lower[name.size()] = '\0';
      if (std::string_view(lower) == "mcp-protocol-version") {
        return value;
      }
    }
  }
  return protocol::McpProtocolVersion;
}
 
inline bool wire_version_requires_result_type(
    std::string_view version) noexcept {
  return version == protocol::McpProtocolVersion2026_07_28 ||
         version == "DRAFT-2026-v1";
}
 
inline bool method_requires_cache_hints(std::string_view method) noexcept {
  return method == protocol::ServerDiscoverMethod ||
         method == protocol::ToolsListMethod ||
         method == protocol::PromptsListMethod ||
         method == protocol::ResourcesListMethod ||
         method == protocol::ResourcesTemplatesListMethod ||
         method == protocol::ResourcesReadMethod;
}
 
using NotificationHandler = std::function<core::Result<core::Unit>(
    const protocol::JsonRpcNotification&, const SessionContext&)>;
 
class Transport {
 public:
  virtual ~Transport() = default;
 
  std::weak_ptr<void> lifetime_token() const noexcept {
    return lifetime_token_;
  }
 
  virtual core::Result<core::Unit> start(
      RequestHandler handler,
      NotificationHandler notification_handler = {}) = 0;
 
  virtual core::Result<protocol::JsonRpcResponse> send_request(
      const protocol::JsonRpcRequest& request) {
    (void)request;
    return mcp::core::unexpected(core::Error{
        static_cast<int>(protocol::ErrorCode::MethodNotFound),
        "transport does not support outbound requests",
        {},
    });
  }
 
  virtual core::Result<protocol::JsonRpcResponse> send_request_to_session(
      std::string_view session_id, const protocol::JsonRpcRequest& request) {
    (void)session_id;
    return send_request(request);
  }
 
  virtual std::optional<protocol::ClientCapabilities> client_capabilities()
      const {
    return std::nullopt;
  }
 
  virtual std::optional<protocol::ClientCapabilities>
  client_capabilities_for_session(std::string_view session_id) const {
    (void)session_id;
    return client_capabilities();
  }
 
  virtual core::Result<core::Unit> send_notification(
      const protocol::JsonRpcNotification& notification) = 0;
 
  virtual core::Result<core::Unit> send_notification_to_session(
      std::string_view session_id,
      const protocol::JsonRpcNotification& notification) {
    (void)session_id;
    return send_notification(notification);
  }
 
  virtual void publish_subscription_notification(std::string_view method,
                                                 protocol::Json params) {
    (void)method;
    (void)params;
  }
 
  virtual void stop() noexcept = 0;
 
  virtual std::string_view name() const noexcept = 0;
 
  virtual void wait_until_ready() {}
 
 private:
  std::shared_ptr<void> lifetime_token_ = std::make_shared<int>(0);
};
 
}  // namespace mcp::server