feat: add tool timeouts, context transport, ping middleware

Author: 0xeb

CMakeLists.txt

@@ -226,6 +226,10 @@ if(FASTMCPP_BUILD_TESTS)
   target_link_libraries(fastmcpp_tools_manager PRIVATE fastmcpp_core)
   add_test(NAME fastmcpp_tools_manager COMMAND fastmcpp_tools_manager)
 
+  add_executable(fastmcpp_tools_timeout tests/tools/test_tool_timeout.cpp)
+  target_link_libraries(fastmcpp_tools_timeout PRIVATE fastmcpp_core)
+  add_test(NAME fastmcpp_tools_timeout COMMAND fastmcpp_tools_timeout)
+
   add_executable(fastmcpp_integration tests/integration.cpp)
   target_link_libraries(fastmcpp_integration PRIVATE fastmcpp_core)
   add_test(NAME fastmcpp_integration COMMAND fastmcpp_integration)

include/fastmcpp/app.hpp

@@ -7,6 +7,7 @@
 #include "fastmcpp/server/server.hpp"
 #include "fastmcpp/tools/manager.hpp"
 
+#include <chrono>
 #include <memory>
 #include <optional>
 #include <string>
@@ -65,6 +66,7 @@ class FastMCP
         std::vector<std::string> exclude_args;
         TaskSupport task_support{TaskSupport::Forbidden};
         Json output_schema{Json::object()};
+        std::optional<std::chrono::milliseconds> timeout;
     };
 
     struct PromptOptions
@@ -250,7 +252,7 @@ class FastMCP
     // =========================================================================
 
     /// Invoke a tool by name (handles prefixed routing)
-    Json invoke_tool(const std::string& name, const Json& args) const;
+    Json invoke_tool(const std::string& name, const Json& args, bool enforce_timeout = true) const;
 
     /// Read a resource by URI (handles prefixed routing)
     resources::ResourceContent read_resource(const std::string& uri,

include/fastmcpp/exceptions.hpp

@@ -20,6 +20,11 @@ struct ValidationError : public Error
     using Error::Error;
 };
 
+struct ToolTimeoutError : public Error
+{
+    using Error::Error;
+};
+
 struct TransportError : public Error
 {
     using Error::Error;

include/fastmcpp/proxy.hpp

@@ -107,7 +107,8 @@ class ProxyApp
 
     /// Invoke a tool by name
     /// Tries local tools first, falls back to remote
-    client::CallToolResult invoke_tool(const std::string& name, const Json& args) const;
+    client::CallToolResult invoke_tool(const std::string& name, const Json& args,
+                                       bool enforce_timeout = true) const;
 
     /// Read a resource by URI
     /// Tries local resources first, falls back to remote

include/fastmcpp/server/context.hpp

@@ -36,6 +36,13 @@ enum class LogLevel
     Error
 };
 
+enum class TransportType
+{
+    Stdio,
+    Sse,
+    StreamableHttp
+};
+
 // ============================================================================
 // Sampling types (for Context.sample())
 // ============================================================================
@@ -146,6 +153,21 @@ inline std::string to_string(LogLevel level)
     }
 }
 
+inline std::string to_string(TransportType transport)
+{
+    switch (transport)
+    {
+    case TransportType::Stdio:
+        return "stdio";
+    case TransportType::Sse:
+        return "sse";
+    case TransportType::StreamableHttp:
+        return "streamable-http";
+    default:
+        return "unknown";
+    }
+}
+
 using LogCallback = std::function<void(LogLevel, const std::string&, const std::string&)>;
 using ProgressCallback =
     std::function<void(const std::string&, double, double, const std::string&)>;
@@ -158,7 +180,8 @@ class Context
     Context(const resources::ResourceManager& rm, const prompts::PromptManager& pm,
             std::optional<fastmcpp::Json> request_meta,
             std::optional<std::string> request_id = std::nullopt,
-            std::optional<std::string> session_id = std::nullopt);
+            std::optional<std::string> session_id = std::nullopt,
+            std::optional<TransportType> transport = std::nullopt);
 
     std::vector<resources::Resource> list_resources() const;
     std::vector<prompts::Prompt> list_prompts() const;
@@ -177,6 +200,16 @@ class Context
     {
         return session_id_;
     }
+    std::optional<std::string> transport() const
+    {
+        if (!transport_.has_value())
+            return std::nullopt;
+        return to_string(*transport_);
+    }
+    std::optional<TransportType> transport_type() const
+    {
+        return transport_;
+    }
 
     std::optional<std::string> client_id() const
     {
@@ -398,6 +431,7 @@ class Context
     std::optional<fastmcpp::Json> request_meta_;
     std::optional<std::string> request_id_;
     std::optional<std::string> session_id_;
+    std::optional<TransportType> transport_;
     mutable std::unordered_map<std::string, std::any> state_;
     LogCallback log_callback_;
     ProgressCallback progress_callback_;

include/fastmcpp/server/middleware_pipeline.hpp

@@ -7,17 +7,24 @@
 /// - Middleware base class with virtual hooks
 /// - Built-in implementations: Logging, Timing, Caching, RateLimiting, ErrorHandling
 
-#include "fastmcpp/types.hpp"
-
-#include <chrono>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <string>
-#include <unordered_map>
-#include <vector>
+#include "fastmcpp/server/session.hpp"
+#include "fastmcpp/types.hpp"
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
 
 namespace fastmcpp::server
 {
@@ -32,11 +39,12 @@ struct MiddlewareContext
     std::string method;                              ///< MCP method name (e.g., "tools/call")
     std::string source{"client"};                    ///< Origin: "client" or "server"
     std::string type{"request"};                     ///< Message type: "request" or "notification"
-    std::chrono::steady_clock::time_point timestamp; ///< Request timestamp
-    std::optional<std::string> request_id;           ///< Request ID if available
-    std::optional<std::string> tool_name;            ///< Tool name for tools/call
-    std::optional<std::string> resource_uri;         ///< Resource URI for resources/read
-    std::optional<std::string> prompt_name;          ///< Prompt name for prompts/get
+    std::chrono::steady_clock::time_point timestamp; ///< Request timestamp
+    std::optional<std::string> request_id;           ///< Request ID if available
+    std::shared_ptr<ServerSession> session;          ///< ServerSession for this request (optional)
+    std::optional<std::string> tool_name;            ///< Tool name for tools/call
+    std::optional<std::string> resource_uri;         ///< Resource URI for resources/read
+    std::optional<std::string> prompt_name;          ///< Prompt name for prompts/get
 
     /// Create a copy with modified fields
     MiddlewareContext copy() const
@@ -502,8 +510,8 @@ class RateLimitingMiddleware : public Middleware
 };
 
 /// Error handling middleware - catches exceptions and converts to MCP errors
-class ErrorHandlingMiddleware : public Middleware
-{
+class ErrorHandlingMiddleware : public Middleware
+{
   public:
     using ErrorCallback = std::function<void(const std::string& method, const std::exception& e)>;
 
@@ -570,7 +578,125 @@ class ErrorHandlingMiddleware : public Middleware
     ErrorCallback callback_;
     bool include_trace_;
     mutable std::mutex mutex_;
-    std::unordered_map<std::string, size_t> error_counts_;
-};
-
-} // namespace fastmcpp::server
+    std::unordered_map<std::string, size_t> error_counts_;
+};
+
+/// Ping middleware - sends periodic pings to keep client connections alive
+class PingMiddleware : public Middleware
+{
+  public:
+    explicit PingMiddleware(std::chrono::milliseconds interval = std::chrono::milliseconds(30000))
+        : interval_(interval)
+    {
+        if (interval_.count() <= 0)
+            throw std::invalid_argument("interval must be positive");
+    }
+
+    explicit PingMiddleware(int interval_ms)
+        : PingMiddleware(std::chrono::milliseconds(interval_ms))
+    {
+    }
+
+    ~PingMiddleware() override
+    {
+        stop();
+    }
+
+    Json operator()(const MiddlewareContext& ctx, CallNext call_next) override
+    {
+        if (ctx.session)
+            ensure_session(ctx.session);
+        return call_next(ctx);
+    }
+
+  private:
+    void ensure_session(const std::shared_ptr<ServerSession>& session)
+    {
+        const std::string key = session_key(session);
+        if (key.empty())
+            return;
+
+        bool should_start = false;
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            if (active_sessions_.insert(key).second)
+                should_start = true;
+        }
+
+        if (!should_start)
+            return;
+
+        std::weak_ptr<ServerSession> weak_session = session;
+        std::thread worker([this, weak_session, key]() { ping_loop(weak_session, key); });
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            threads_.push_back(std::move(worker));
+        }
+    }
+
+    void ping_loop(std::weak_ptr<ServerSession> weak_session, const std::string& key)
+    {
+        while (true)
+        {
+            {
+                std::unique_lock<std::mutex> lock(mutex_);
+                if (cv_.wait_for(lock, interval_, [this]() { return stop_.load(); }))
+                    break;
+            }
+
+            if (stop_.load())
+                break;
+
+            auto session = weak_session.lock();
+            if (!session)
+                break;
+
+            try
+            {
+                session->send_ping(interval_);
+            }
+            catch (const std::exception&)
+            {
+                break;
+            }
+        }
+
+        std::lock_guard<std::mutex> lock(mutex_);
+        active_sessions_.erase(key);
+    }
+
+    void stop()
+    {
+        stop_.store(true);
+        cv_.notify_all();
+
+        std::vector<std::thread> threads;
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            threads.swap(threads_);
+        }
+
+        for (auto& t : threads)
+            if (t.joinable())
+                t.join();
+    }
+
+    static std::string session_key(const std::shared_ptr<ServerSession>& session)
+    {
+        if (!session)
+            return {};
+        auto key = session->session_id();
+        if (!key.empty())
+            return key;
+        return "session@" + std::to_string(reinterpret_cast<std::uintptr_t>(session.get()));
+    }
+
+    std::chrono::milliseconds interval_;
+    std::mutex mutex_;
+    std::condition_variable cv_;
+    std::unordered_set<std::string> active_sessions_;
+    std::vector<std::thread> threads_;
+    std::atomic<bool> stop_{false};
+};
+
+} // namespace fastmcpp::server

include/fastmcpp/server/session.hpp

@@ -291,6 +291,18 @@ class ServerSession
             send_callback_(notification);
     }
 
+    /**
+     * Send a ping request to the client and wait for a response.
+     *
+     * @param timeout How long to wait for response
+     * @throws RequestTimeoutError if timeout exceeded
+     * @throws ClientError if client returns an error
+     */
+    void send_ping(std::chrono::milliseconds timeout = DEFAULT_TIMEOUT)
+    {
+        (void)send_request("ping", Json::object(), timeout);
+    }
+
     /**
      * Send a progress notification to the client.
      *

include/fastmcpp/tools/manager.hpp

@@ -19,12 +19,13 @@ class ToolManager
     {
         return tools_.at(name);
     }
-    fastmcpp::Json invoke(const std::string& name, const fastmcpp::Json& input) const
+    fastmcpp::Json invoke(const std::string& name, const fastmcpp::Json& input,
+                          bool enforce_timeout = true) const
     {
         auto it = tools_.find(name);
         if (it == tools_.end())
             throw fastmcpp::NotFoundError("tool not found: " + name);
-        return it->second.invoke(input);
+        return it->second.invoke(input, enforce_timeout);
     }
 
     std::vector<std::string> list_names() const