http_transport.hpp

Go to the documentation of this file.

// Copyright (c) 2025 [caomengxuan666]
 
#pragma once
 
 
#include <chrono>
#include <cstddef>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "cxxmcp/transport/transport.hpp"
 
namespace mcp::transport {
 
struct StreamableHttpAuthChallenge {
  int status_code = 0;
  std::string method;
  std::unordered_map<std::string, std::string> headers;
  std::optional<std::string> www_authenticate;
};
 
using StreamableHttpAuthRefreshHandler =
    std::function<std::optional<std::string>(
        const StreamableHttpAuthChallenge&)>;
 
struct StreamableHttpClientTransportOptions {
  std::string uri;
 
  std::string host;
 
  int port = 80;
 
  std::string path = "/";
 
  std::unordered_map<std::string, std::string> headers;
 
  std::optional<std::string> auth_header;
 
  StreamableHttpAuthRefreshHandler auth_refresh_handler;
 
  bool stateless = false;
 
  std::chrono::milliseconds timeout{30000};
};
 
class StreamableHttpClientTransport final : public ClientTransport {
 public:
  explicit StreamableHttpClientTransport(
      StreamableHttpClientTransportOptions options);
  ~StreamableHttpClientTransport() override;
 
  StreamableHttpClientTransport(const StreamableHttpClientTransport&) = delete;
  StreamableHttpClientTransport& operator=(
      const StreamableHttpClientTransport&) = delete;
 
  std::string_view name() const noexcept override;
  protocol::Json diagnostics() const override;
  core::Result<core::Unit> send(TxMessage message) override;
  core::Result<std::optional<RxMessage>> receive() override;
  core::Result<core::Unit> close() override;
 
 private:
  class Impl;
 
  std::unique_ptr<Impl> impl_;
};
 
struct StreamableHttpServerTransportOptions {
  std::string listen_host = "127.0.0.1";
 
  int listen_port = 0;
 
  std::string path = "/mcp";
 
  std::optional<std::chrono::milliseconds> sse_retry;
 
  bool enable_sse_polling = false;
 
  std::chrono::milliseconds sse_disconnect_retry{5000};
 
  std::vector<std::string> allowed_origins;
 
  std::vector<std::string> allowed_hosts = {"localhost", "127.0.0.1", "::1"};
 
  std::size_t max_pending_sse_events = 1024;
 
  std::size_t max_pending_sse_bytes = 4 * 1024 * 1024;
 
  std::size_t max_sse_replay_events = 256;
 
  std::chrono::milliseconds request_timeout{30000};
 
  std::size_t max_request_body_bytes = 10 * 1024 * 1024;
 
  std::chrono::milliseconds read_timeout{30000};
 
  std::chrono::milliseconds write_timeout{30000};
 
  std::size_t max_sessions = 1024;
 
  bool stateless = false;
};
 
struct StreamableHttpServerMessageContext {
  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;
};
 
class StreamableHttpServerTransport final : public ServerTransport {
 public:
  explicit StreamableHttpServerTransport(
      StreamableHttpServerTransportOptions options);
  ~StreamableHttpServerTransport() override;
 
  StreamableHttpServerTransport(const StreamableHttpServerTransport&) = delete;
  StreamableHttpServerTransport& operator=(
      const StreamableHttpServerTransport&) = delete;
 
  std::string_view name() const noexcept override;
  protocol::Json diagnostics() const override;
  core::Result<core::Unit> send(TxMessage message) override;
  core::Result<std::optional<RxMessage>> receive() override;
  std::optional<StreamableHttpServerMessageContext> last_received_context()
      const;
  core::Result<core::Unit> close() override;
  void wait_until_ready() override;
 
 private:
  class Impl;
 
  std::unique_ptr<Impl> impl_;
};
 
}  // namespace mcp::transport