server.hpp

Go to the documentation of this file.

// Copyright (c) 2025 [caomengxuan666]
 
#pragma once
 
 
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "cxxmcp/core/result.hpp"
#include "cxxmcp/protocol/capabilities.hpp"
#include "cxxmcp/protocol/logging.hpp"
#include "cxxmcp/protocol/task.hpp"
#include "cxxmcp/server/auth.hpp"
#include "cxxmcp/server/context.hpp"
#include "cxxmcp/server/rate_limit.hpp"
#include "cxxmcp/server/registry.hpp"
#include "cxxmcp/server/schema_validator.hpp"
#include "cxxmcp/server/task_manager.hpp"
#include "cxxmcp/server/transport.hpp"
 
namespace mcp::server {
 
struct ServerOptions {
  protocol::ServerCapabilities capabilities;
 
  std::string server_name = "cxxmcp";
 
  std::string server_version = "2.0.0";
 
  std::string instructions;
};
 
struct ServerInfo {
  std::string name;
 
  std::string version;
 
  std::string instructions;
};
 
struct ServerHandler;
struct ServerHandlerInterface;
 
class Server {
 public:
  explicit Server(ServerOptions options);
 
  ~Server();
 
  Server(const Server&) = delete;
  Server& operator=(const Server&) = delete;
  Server(Server&&) noexcept;
  Server& operator=(Server&&) noexcept;
 
  ServerInfo get_info() const;
 
  const protocol::ServerCapabilities& capabilities() const noexcept;
 
  ToolRegistry& tools() noexcept;
 
  const ToolRegistry& tools() const noexcept;
 
  std::vector<protocol::ToolDefinition> list_tools() const;
 
  core::Result<protocol::ToolsListResult> list_tools(
      const protocol::PaginatedRequestParams& params,
      const SessionContext& context) const;
 
  core::Result<protocol::ToolDefinition> get_tool(std::string_view name) const;
 
  core::Result<protocol::ToolResult> call_tool(
      std::string_view name,
      protocol::Json arguments = protocol::Json::object(),
      const std::string& session_id = {}) const;
  core::Result<protocol::ToolResult> call_tool(
      std::string_view name, protocol::Json arguments,
      const SessionContext& context,
      CancellationToken cancellation = CancellationToken::none()) const;
 
  Server& use_task_manager(TaskOperationProcessorOptions options = {});
 
  Server& use_task_manager(std::shared_ptr<TaskOperationProcessor> processor);
 
  std::shared_ptr<TaskOperationProcessor> task_manager() const noexcept;
 
  PromptRegistry& prompts() noexcept;
 
  const PromptRegistry& prompts() const noexcept;
 
  std::vector<protocol::Prompt> list_prompts() const;
 
  core::Result<protocol::PromptsListResult> list_prompts(
      const protocol::PaginatedRequestParams& params,
      const SessionContext& context) const;
 
  core::Result<protocol::PromptsGetResult> get_prompt(
      std::string_view name,
      protocol::Json arguments = protocol::Json::object(),
      const std::string& session_id = {}) const;
  core::Result<protocol::PromptsGetResult> get_prompt(
      std::string_view name, protocol::Json arguments,
      const SessionContext& context,
      CancellationToken cancellation = CancellationToken::none()) const;
 
  ResourceRegistry& resources() noexcept;
 
  const ResourceRegistry& resources() const noexcept;
 
  std::vector<protocol::Resource> list_resources() const;
 
  core::Result<protocol::ResourcesListResult> list_resources(
      const protocol::PaginatedRequestParams& params,
      const SessionContext& context) const;
 
  core::Result<protocol::ResourcesReadResult> read_resource(
      std::string_view uri, protocol::Json params = protocol::Json::object(),
      const std::string& session_id = {}) const;
  core::Result<protocol::ResourcesReadResult> read_resource(
      std::string_view uri, protocol::Json params,
      const SessionContext& context,
      CancellationToken cancellation = CancellationToken::none()) const;
 
  ResourceTemplateRegistry& resource_templates() noexcept;
 
  const ResourceTemplateRegistry& resource_templates() const noexcept;
 
  std::vector<protocol::ResourceTemplate> list_resource_templates() const;
 
  core::Result<protocol::ResourceTemplatesListResult> list_resource_templates(
      const protocol::PaginatedRequestParams& params,
      const SessionContext& context) const;
 
  core::Result<protocol::Json> initialize();
 
  core::Result<protocol::Json> ping(const SessionContext& context = {});
 
  core::Result<protocol::JsonRpcResponse> handle_request(
      const protocol::JsonRpcRequest& request, const SessionContext& context);
 
  core::Result<protocol::JsonRpcResponse> handle_request_impl(
      const protocol::JsonRpcRequest& request, const SessionContext& context);
 
  core::Result<SessionContext> authenticate_context(
      const SessionContext& context);
 
  core::Result<core::Unit> handle_notification(
      const protocol::JsonRpcNotification& notification,
      const SessionContext& context);
 
  core::Result<core::Unit> notify_roots_list_changed();
 
  core::Result<core::Unit> notify_tool_list_changed();
 
  core::Result<core::Unit> notify_prompt_list_changed();
 
  core::Result<core::Unit> notify_resource_list_changed();
 
  core::Result<core::Unit> notify_resource_updated(std::string_view uri);
 
  core::Result<core::Unit> set_resource_subscription(
      const SessionContext& context, std::string_view uri, bool subscribed);
 
  core::Result<core::Unit> notify_progress(
      const protocol::ProgressNotificationParams& params);
 
  core::Result<core::Unit> notify_logging_message(
      const protocol::LoggingMessageNotificationParams& params);
 
  core::Result<core::Unit> notify_elicitation_complete(
      std::string elicitation_id);
 
  core::Result<core::Unit> notify_task_status(const protocol::Task& task);
 
  core::Result<protocol::CreateTaskResult> enqueue_task(
      const protocol::Task& task);
 
  core::Result<core::Unit> add_transport(std::unique_ptr<Transport> transport);
 
  core::Result<core::Unit> add_session_transport(Transport& transport);
 
  void set_auth_provider(std::unique_ptr<AuthProvider> auth_provider);
 
  void set_rate_limiter(std::unique_ptr<RateLimiter> rate_limiter);
 
  void set_schema_validator(
      std::shared_ptr<const JsonSchemaValidator> validator);
 
  std::shared_ptr<const JsonSchemaValidator> schema_validator() const noexcept {
    return schema_validator_;
  }
 
  core::Result<core::Unit> start();
 
  void stop() noexcept;
 
  using JsonHandler =
      std::function<core::Result<protocol::Json>(const protocol::Json&)>;
  using JsonContextHandler = std::function<core::Result<protocol::Json>(
      const protocol::Json&, const SessionContext&)>;
  using JsonRequestContextHandler = std::function<core::Result<protocol::Json>(
      const protocol::Json&, const SessionContext&, CancellationToken)>;
 
  using LoggingHandler =
      std::function<void(std::string_view, std::string_view)>;
 
  using RawRequestHandler =
      std::function<std::optional<protocol::JsonRpcResponse>(
          const protocol::JsonRpcRequest&, const SessionContext&)>;
  using RawRequestContextHandler =
      std::function<std::optional<protocol::JsonRpcResponse>(
          const protocol::JsonRpcRequest&, const SessionContext&,
          CancellationToken)>;
 
  using RawNotificationHandler = std::function<core::Result<core::Unit>(
      const protocol::JsonRpcNotification&, const SessionContext&)>;
 
  using TaskListHandler = std::function<core::Result<protocol::TaskListResult>(
      const protocol::TaskListParams&, const SessionContext&)>;
 
  using ToolsListHandler =
      std::function<core::Result<protocol::ToolsListResult>(
          const protocol::PaginatedRequestParams&, const SessionContext&)>;
 
  using PromptsListHandler =
      std::function<core::Result<protocol::PromptsListResult>(
          const protocol::PaginatedRequestParams&, const SessionContext&)>;
 
  using ResourcesListHandler =
      std::function<core::Result<protocol::ResourcesListResult>(
          const protocol::PaginatedRequestParams&, const SessionContext&)>;
 
  using ResourceTemplatesListHandler =
      std::function<core::Result<protocol::ResourceTemplatesListResult>(
          const protocol::PaginatedRequestParams&, const SessionContext&)>;
 
  using TaskGetHandler = std::function<core::Result<protocol::Task>(
      const protocol::TaskGetParams&, const SessionContext&)>;
 
  using TaskCancelHandler = std::function<core::Result<protocol::Task>(
      const protocol::TaskCancelParams&, const SessionContext&)>;
 
  using TaskResultHandler = std::function<core::Result<protocol::Json>(
      const protocol::TaskResultParams&, const SessionContext&)>;
 
  using RootsListChangedHandler =
      std::function<core::Result<core::Unit>(const SessionContext&)>;
 
  using ProgressHandler = std::function<core::Result<core::Unit>(
      const protocol::ProgressNotificationParams&, const SessionContext&)>;
 
  using ListChangedHandler =
      std::function<core::Result<core::Unit>(const SessionContext&)>;
 
  using ResourceUpdatedHandler = std::function<core::Result<core::Unit>(
      const std::string& uri, const SessionContext&)>;
 
  void set_completion_handler(JsonHandler handler);
  void set_completion_handler(JsonContextHandler handler);
  void set_completion_handler(JsonRequestContextHandler handler);
 
  void set_sampling_handler(JsonHandler handler);
  void set_sampling_handler(JsonContextHandler handler);
  void set_sampling_handler(JsonRequestContextHandler handler);
 
  void set_logging_handler(LoggingHandler handler);
 
  void set_raw_request_handler(RawRequestHandler handler);
  void set_raw_request_handler(RawRequestContextHandler handler);
 
  const RawRequestHandler& raw_request_handler() const noexcept {
    return raw_request_handler_;
  }
 
  const RawRequestContextHandler& raw_request_context_handler() const noexcept {
    return raw_request_context_handler_;
  }
 
  void set_raw_notification_handler(RawNotificationHandler handler);
 
  void set_custom_request_handler(RawRequestHandler handler);
  void set_custom_request_handler(RawRequestContextHandler handler);
 
  void set_custom_notification_handler(RawNotificationHandler handler);
 
  void set_task_list_handler(TaskListHandler handler);
 
  void set_tools_list_handler(ToolsListHandler handler);
 
  void set_prompts_list_handler(PromptsListHandler handler);
 
  void set_resources_list_handler(ResourcesListHandler handler);
 
  void set_resource_templates_list_handler(
      ResourceTemplatesListHandler handler);
 
  void set_task_get_handler(TaskGetHandler handler);
 
  void set_task_cancel_handler(TaskCancelHandler handler);
 
  void set_task_result_handler(TaskResultHandler handler);
 
  void set_progress_handler(ProgressHandler handler);
 
  void set_roots_list_changed_handler(RootsListChangedHandler handler);
 
  void set_tool_list_changed_handler(ListChangedHandler handler);
 
  void set_prompt_list_changed_handler(ListChangedHandler handler);
 
  void set_resource_list_changed_handler(ListChangedHandler handler);
 
  void set_resource_updated_handler(ResourceUpdatedHandler handler);
 
  Server& set_handler(const ServerHandler& handler);
 
  Server& set_handler(const ServerHandlerInterface& handler);
 
  Server& set_handler(std::shared_ptr<const ServerHandlerInterface> handler);
 
 private:
  template <typename Handler>
  Handler copy_handler(Handler Server::* slot) const {
    std::lock_guard<std::mutex> lock(*handlers_mutex_);
    return this->*slot;
  }
 
  template <typename Handler>
  void store_handler(Handler Server::* slot, Handler handler) {
    std::lock_guard<std::mutex> lock(*handlers_mutex_);
    this->*slot = std::move(handler);
  }
 
  ServerOptions options_;
  ToolRegistry tools_;
  PromptRegistry prompts_;
  ResourceRegistry resources_;
  ResourceTemplateRegistry resource_templates_;
  std::shared_ptr<TaskOperationProcessor> task_processor_;
  std::unique_ptr<AuthProvider> auth_provider_;
  std::unique_ptr<RateLimiter> rate_limiter_;
  std::shared_ptr<const JsonSchemaValidator> schema_validator_;
  std::vector<std::unique_ptr<Transport>> transports_;
  JsonRequestContextHandler completion_handler_;
  JsonRequestContextHandler sampling_handler_;
  LoggingHandler logging_handler_;
  RawRequestHandler raw_request_handler_;
  RawRequestContextHandler raw_request_context_handler_;
  RawNotificationHandler raw_notification_handler_;
  ToolsListHandler tools_list_handler_;
  PromptsListHandler prompts_list_handler_;
  ResourcesListHandler resources_list_handler_;
  ResourceTemplatesListHandler resource_templates_list_handler_;
  TaskListHandler task_list_handler_;
  TaskGetHandler task_get_handler_;
  TaskCancelHandler task_cancel_handler_;
  TaskResultHandler task_result_handler_;
  ProgressHandler progress_handler_;
  RootsListChangedHandler roots_list_changed_handler_;
  ListChangedHandler tool_list_changed_handler_;
  ListChangedHandler prompt_list_changed_handler_;
  ListChangedHandler resource_list_changed_handler_;
  ResourceUpdatedHandler resource_updated_handler_;
  mutable std::shared_ptr<std::mutex> handlers_mutex_ =
      std::make_shared<std::mutex>();
  std::unordered_map<Transport*, std::unordered_set<std::string>>
      resource_subscriptions_;
  std::vector<Transport*> session_transports_;
  std::unordered_set<Transport*> session_transport_set_;
  std::shared_ptr<std::mutex> subscriptions_mutex_ =
      std::make_shared<std::mutex>();
 
  core::Result<core::Unit> broadcast_notification(
      const protocol::JsonRpcNotification& notification);
  core::Result<core::Unit> notify_resource_subscribers(
      std::string_view uri, const protocol::JsonRpcNotification& notification);
  CancellationToken begin_request_cancellation(
      const protocol::RequestId& request_id);
  void end_request_cancellation(const protocol::RequestId& request_id) noexcept;
  void cancel_request(const protocol::RequestId& request_id) noexcept;
 
  std::shared_ptr<std::mutex> active_request_cancellations_mutex_ =
      std::make_shared<std::mutex>();
  std::unordered_map<std::string, CancellationSource>
      active_request_cancellations_;
};
 
class ServerBuilder {
 public:
  ServerBuilder& name(std::string value);
 
  ServerBuilder& version(std::string value);
 
  ServerBuilder& instructions(std::string value);
 
  ServerBuilder& with_capabilities(protocol::ServerCapabilities capabilities);
 
  ServerBuilder& with_transport(std::unique_ptr<Transport> transport);
 
  ServerBuilder& with_auth_provider(
      std::unique_ptr<AuthProvider> auth_provider);
 
  ServerBuilder& with_rate_limiter(std::unique_ptr<RateLimiter> rate_limiter);
 
  ServerBuilder& with_schema_validator(
      std::shared_ptr<const JsonSchemaValidator> validator);
 
  ServerBuilder& with_task_manager(TaskOperationProcessorOptions options = {});
 
  ServerBuilder& with_task_manager(
      std::shared_ptr<TaskOperationProcessor> processor);
 
  ServerBuilder& add_tool(protocol::ToolDefinition definition,
                          ToolHandler handler);
 
  ServerBuilder& add_prompt(protocol::Prompt prompt, PromptHandler handler);
 
  ServerBuilder& add_resource(protocol::Resource resource,
                              ResourceReadHandler handler);
 
  ServerBuilder& add_resource_template(
      protocol::ResourceTemplate resource_template);
 
  template <class Router>
  ServerBuilder& with_router(const Router& router) {
    return router.apply_to(*this);
  }
 
  ServerBuilder& on_completion(Server::JsonHandler handler);
  ServerBuilder& on_completion(Server::JsonContextHandler handler);
  ServerBuilder& on_completion(Server::JsonRequestContextHandler handler);
 
  ServerBuilder& on_sampling(Server::JsonHandler handler);
  ServerBuilder& on_sampling(Server::JsonContextHandler handler);
  ServerBuilder& on_sampling(Server::JsonRequestContextHandler handler);
 
  ServerBuilder& on_logging(Server::LoggingHandler handler);
 
  ServerBuilder& on_raw_request(Server::RawRequestHandler handler);
 
  ServerBuilder& on_raw_notification(Server::RawNotificationHandler handler);
 
  ServerBuilder& on_custom_request(Server::RawRequestHandler handler);
 
  ServerBuilder& on_custom_notification(Server::RawNotificationHandler handler);
 
  ServerBuilder& on_task_list(Server::TaskListHandler handler);
 
  ServerBuilder& on_tools_list(Server::ToolsListHandler handler);
 
  ServerBuilder& on_prompts_list(Server::PromptsListHandler handler);
 
  ServerBuilder& on_resources_list(Server::ResourcesListHandler handler);
 
  ServerBuilder& on_resource_templates_list(
      Server::ResourceTemplatesListHandler handler);
 
  ServerBuilder& on_task_get(Server::TaskGetHandler handler);
 
  ServerBuilder& on_task_cancel(Server::TaskCancelHandler handler);
 
  ServerBuilder& on_task_result(Server::TaskResultHandler handler);
 
  ServerBuilder& on_progress(Server::ProgressHandler handler);
 
  ServerBuilder& on_roots_list_changed(Server::RootsListChangedHandler handler);
 
  ServerBuilder& on_tool_list_changed(Server::ListChangedHandler handler);
 
  ServerBuilder& on_prompt_list_changed(Server::ListChangedHandler handler);
 
  ServerBuilder& on_resource_list_changed(Server::ListChangedHandler handler);
 
  ServerBuilder& on_resource_updated(Server::ResourceUpdatedHandler handler);
 
  ServerBuilder& with_handler(ServerHandler handler);
 
  ServerBuilder& with_handler(const ServerHandlerInterface& handler);
 
  ServerBuilder& with_handler(
      std::shared_ptr<const ServerHandlerInterface> handler);
 
  core::Result<std::unique_ptr<Server>> build();
 
 private:
  using ServerRegistration = std::function<core::Result<core::Unit>(Server&)>;
 
  ServerOptions options_;
  std::unique_ptr<AuthProvider> auth_provider_;
  std::unique_ptr<RateLimiter> rate_limiter_;
  std::shared_ptr<const JsonSchemaValidator> schema_validator_;
  std::shared_ptr<TaskOperationProcessor> task_processor_;
  std::vector<std::unique_ptr<Transport>> transports_;
  std::vector<ServerRegistration> registrations_;
  Server::JsonRequestContextHandler completion_handler_;
  Server::JsonRequestContextHandler sampling_handler_;
  Server::LoggingHandler logging_handler_;
  Server::RawRequestHandler raw_request_handler_;
  Server::RawNotificationHandler raw_notification_handler_;
  Server::ToolsListHandler tools_list_handler_;
  Server::PromptsListHandler prompts_list_handler_;
  Server::ResourcesListHandler resources_list_handler_;
  Server::ResourceTemplatesListHandler resource_templates_list_handler_;
  Server::TaskListHandler task_list_handler_;
  Server::TaskGetHandler task_get_handler_;
  Server::TaskCancelHandler task_cancel_handler_;
  Server::TaskResultHandler task_result_handler_;
  Server::ProgressHandler progress_handler_;
  Server::RootsListChangedHandler roots_list_changed_handler_;
  Server::ListChangedHandler tool_list_changed_handler_;
  Server::ListChangedHandler prompt_list_changed_handler_;
  Server::ListChangedHandler resource_list_changed_handler_;
  Server::ResourceUpdatedHandler resource_updated_handler_;
};
 
}  // namespace mcp::server