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/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&)>;
 
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 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