fix(ci): clang-format sweep + unblock base.hpp + streaming tests

Addresses the CI failures on PR #41:

- Format-check: clang-format pass across 26 files flagged by the
  workflow. Most are pre-existing drift (client/**, providers/search/**,
  server/streamable_http_server.*, mcp/handler.cpp, etc.) unrelated to
  F1-F9; the remainder are the F1-F9 surface itself.
- base.hpp compile error on gcc/clang: splits
  BaseSearchTransform(Options opts = {}) into a defaulted no-arg
  delegating ctor + explicit Options ctor, fixing the
  "default member initializer needed within definition of enclosing
  class outside of member functions" diagnostic. Pre-existing on main
  since 2026-03-18.
- streaming_sse and example_streaming_demo flakes: both handlers now
  return a proper JSON-RPC reply (jsonrpc/id/result) so the server's
  post-notification dispatch path no longer drops them as malformed.
  Pre-existing on main.

No functional change to F1-F9 logic.

Author: 0xeb

examples/streaming_demo.cpp

@@ -6,6 +6,7 @@
 #include <chrono>
 #include <httplib.h>
 #include <iostream>
+#include <mutex>
 #include <string>
 #include <thread>
 #include <vector>
@@ -15,11 +16,19 @@ using fastmcpp::server::SseServerWrapper;
 
 int main()
 {
-    auto handler = [](const Json& request) -> Json { return request; };
-    // Bind to any available port and start wrapper
+    // Echo handler: returns a minimal JSON-RPC response carrying the posted value.
+    auto handler = [](const Json& request) -> Json
+    {
+        Json response = {{"jsonrpc", "2.0"},
+                         {"id", request.value("id", Json(nullptr))},
+                         {"result", request.value("params", Json::object())}};
+        return response;
+    };
+
+    // Choose port with fallback range
     int port = -1;
     std::unique_ptr<SseServerWrapper> server;
-    for (int candidate = 18111; candidate <= 18131; ++candidate)
+    for (int candidate = 18110; candidate <= 18130; ++candidate)
     {
         auto trial = std::make_unique<SseServerWrapper>(handler, "127.0.0.1", candidate, "/sse",
                                                         "/messages");
@@ -32,70 +41,85 @@ int main()
     }
     if (port < 0 || !server)
     {
-        std::cerr << "Failed to start SSE server" << std::endl;
+        std::cerr << "Failed to start SSE server on candidates" << std::endl;
         return 1;
     }
+
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
 
-    // Skip strict probe; receiver will retry until connected
+    // Do not hard-fail on probe; the receiver thread retries connections
 
-    std::vector<int> seen;
-    std::mutex m;
+    // Start SSE receiver
     std::atomic<bool> sse_connected{false};
-    std::string session_id;
+    std::atomic<bool> have_endpoint{false};
+    std::string message_endpoint;
+    std::vector<int> seen;
+    std::mutex seen_mutex;
+    std::mutex endpoint_mutex;
+
+    httplib::Client sse_client("127.0.0.1", port);
+    sse_client.set_connection_timeout(std::chrono::seconds(10));
+    sse_client.set_read_timeout(std::chrono::seconds(20));
 
-    // NOTE: httplib::Client must be created in the same thread that uses it on Linux
     std::thread sse_thread(
-        [&, port]()
+        [&]()
         {
-            // Create client inside thread - httplib::Client is not thread-safe across threads on
-            // Linux
-            httplib::Client cli("127.0.0.1", port);
-            cli.set_connection_timeout(std::chrono::seconds(10));
-            cli.set_read_timeout(std::chrono::seconds(20));
-
+            std::string buffer;
             auto receiver = [&](const char* data, size_t len)
             {
                 sse_connected = true;
-                std::string chunk(data, len);
-
-                // Parse SSE endpoint event to extract session_id
-                if (chunk.find("event: endpoint") != std::string::npos)
+                buffer.append(data, len);
+
+                // Process complete SSE blocks separated by a blank line.
+                // Each block can contain lines like:
+                //   event: endpoint
+                //   data: /messages?session_id=...
+                // or:
+                //   data: {json}\n\n
+                while (true)
                 {
-                    size_t data_pos = chunk.find("data: ");
-                    if (data_pos != std::string::npos)
-                    {
-                        size_t start = data_pos + 6;
-                        size_t end = chunk.find_first_of("\n\r", start);
-                        std::string endpoint_url = chunk.substr(start, end - start);
+                    size_t end = buffer.find("\n\n");
+                    if (end == std::string::npos)
+                        break;
 
-                        size_t sid_pos = endpoint_url.find("session_id=");
-                        if (sid_pos != std::string::npos)
+                    std::string block = buffer.substr(0, end);
+                    buffer.erase(0, end + 2);
+
+                    // Extract endpoint path if present
+                    if (block.find("event: endpoint") != std::string::npos)
+                    {
+                        size_t data_pos = block.find("data: ");
+                        if (data_pos != std::string::npos)
                         {
-                            size_t sid_start = sid_pos + 11;
-                            size_t sid_end = endpoint_url.find_first_of("&\n\r", sid_start);
-                            std::lock_guard<std::mutex> lock(m);
-                            session_id = endpoint_url.substr(sid_start, sid_end - sid_start);
+                            size_t value_start = data_pos + 6;
+                            size_t value_end = block.find('\n', value_start);
+                            std::string endpoint =
+                                block.substr(value_start, value_end == std::string::npos
+                                                              ? std::string::npos
+                                                              : value_end - value_start);
+                            {
+                                std::lock_guard<std::mutex> lock(endpoint_mutex);
+                                message_endpoint = endpoint;
+                                have_endpoint = !message_endpoint.empty();
+                            }
                         }
+                        continue;
                     }
-                }
 
-                if (chunk.find("data: ") == 0)
-                {
-                    size_t start = 6;
-                    size_t end = chunk.find("\n\n");
-                    if (end != std::string::npos)
+                    // Parse "data: {json}" events and collect result.n values.
+                    if (block.rfind("data: ", 0) == 0)
                     {
-                        std::string json_str = chunk.substr(start, end - start);
+                        std::string json_str = block.substr(6);
                         try
                         {
                             Json j = Json::parse(json_str);
-                            if (j.contains("n"))
+                            if (j.contains("result") && j["result"].is_object() &&
+                                j["result"].contains("n"))
                             {
-                                std::lock_guard<std::mutex> lock(m);
-                                seen.push_back(j["n"].get<int>());
+                                std::lock_guard<std::mutex> lock(seen_mutex);
+                                seen.push_back(j["result"]["n"].get<int>());
                                 if (seen.size() >= 3)
-                                    return false;
+                                    return false; // stop after 3
                             }
                         }
                         catch (...)
@@ -105,9 +129,9 @@ int main()
                 }
                 return true;
             };
-            for (int attempt = 0; attempt < 20 && !sse_connected; ++attempt)
+            for (int attempt = 0; attempt < 60 && !sse_connected; ++attempt)
             {
-                auto res = cli.Get("/sse", receiver);
+                auto res = sse_client.Get("/sse", receiver);
                 if (!res)
                 {
                     std::this_thread::sleep_for(std::chrono::milliseconds(200));
@@ -118,6 +142,7 @@ int main()
             }
         });
 
+    // Wait for connection
     for (int i = 0; i < 500 && !sse_connected; ++i)
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
     if (!sse_connected)
@@ -129,36 +154,29 @@ int main()
         return 1;
     }
 
-    // Wait for session_id to be extracted
-    for (int i = 0; i < 100; ++i)
-    {
-        std::lock_guard<std::mutex> lock(m);
-        if (!session_id.empty())
-            break;
+    // Wait for server to tell us the message endpoint (includes required session_id).
+    for (int i = 0; i < 500 && !have_endpoint; ++i)
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    }
-
-    std::string sid;
-    {
-        std::lock_guard<std::mutex> lock(m);
-        sid = session_id;
-    }
-
-    if (sid.empty())
+    if (!have_endpoint)
     {
         server->stop();
         if (sse_thread.joinable())
             sse_thread.join();
-        std::cerr << "Failed to extract session_id" << std::endl;
+        std::cerr << "Missing endpoint event" << std::endl;
         return 1;
     }
 
+    // Post three messages
     httplib::Client post("127.0.0.1", port);
+    std::string post_path;
+    {
+        std::lock_guard<std::mutex> lock(endpoint_mutex);
+        post_path = message_endpoint;
+    }
     for (int i = 1; i <= 3; ++i)
     {
-        Json j = Json{{"n", i}};
-        std::string post_url = "/messages?session_id=" + sid;
-        auto res = post.Post(post_url, j.dump(), "application/json");
+        Json j = {{"jsonrpc", "2.0"}, {"id", i}, {"method", "echo"}, {"params", {{"n", i}}}};
+        auto res = post.Post(post_path, j.dump(), "application/json");
         if (!res || res->status != 200)
         {
             server->stop();
@@ -169,23 +187,35 @@ int main()
         }
     }
 
+    // Wait briefly for all events
     for (int i = 0; i < 200; ++i)
     {
-        std::lock_guard<std::mutex> lock(m);
-        if (seen.size() >= 3)
-            break;
+        {
+            std::lock_guard<std::mutex> lock(seen_mutex);
+            if (seen.size() >= 3)
+                break;
+        }
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
     }
 
     server->stop();
     if (sse_thread.joinable())
         sse_thread.join();
 
-    if (seen.size() != 3)
     {
-        std::cerr << "expected 3 events, got " << seen.size() << "\n";
-        return 1;
+        std::lock_guard<std::mutex> lock(seen_mutex);
+        if (seen.size() != 3)
+        {
+            std::cerr << "expected 3 events, got " << seen.size() << "\n";
+            return 1;
+        }
+        if (seen[0] != 1 || seen[1] != 2 || seen[2] != 3)
+        {
+            std::cerr << "unexpected event sequence\n";
+            return 1;
+        }
     }
+
     std::cout << "ok\n";
     return 0;
 }

include/fastmcpp/app.hpp

@@ -49,8 +49,8 @@ struct CustomRouteResponse
 /// fixed forwarding from mounted servers).
 struct CustomRoute
 {
-    std::string method;            // GET, POST, etc. (uppercase)
-    std::string path;              // Absolute path, e.g. "/health" — must start with '/'
+    std::string method; // GET, POST, etc. (uppercase)
+    std::string path;   // Absolute path, e.g. "/health" — must start with '/'
     std::function<CustomRouteResponse(const CustomRouteRequest&)> handler;
 };
 

include/fastmcpp/client/client.hpp

@@ -18,8 +18,8 @@
 #include <future>
 #include <memory>
 #include <mutex>
-#include <string>
 #include <set>
+#include <string>
 #include <thread>
 #include <unordered_map>
 #include <unordered_set>

include/fastmcpp/client/transports.hpp

@@ -124,8 +124,7 @@ class SseClientTransport : public ITransport,
     /// @param sse_path Path for SSE endpoint (default: "/sse")
     /// @param messages_path Path for message endpoint (default: "/messages")
     explicit SseClientTransport(std::string base_url, std::string sse_path = "/sse",
-                                std::string messages_path = "/messages",
-                                bool verify_ssl = true);
+                                std::string messages_path = "/messages", bool verify_ssl = true);
 
     ~SseClientTransport();
 

include/fastmcpp/client/types.hpp

@@ -64,8 +64,8 @@ using ContentBlock = std::variant<TextContent, ImageContent, AudioContent, Embed
 struct ToolInfo
 {
     std::string name;
-    std::optional<std::string> version;               ///< Component version metadata
-    std::optional<std::string> title;                 ///< Human-readable title
+    std::optional<std::string> version; ///< Component version metadata
+    std::optional<std::string> title;   ///< Human-readable title
     std::optional<std::string> description;
     fastmcpp::Json inputSchema;                       ///< JSON Schema for tool input
     std::optional<fastmcpp::Json> outputSchema;       ///< JSON Schema for structured output
@@ -134,8 +134,8 @@ struct ResourceInfo
 {
     std::string uri;
     std::string name;
-    std::optional<std::string> version;               ///< Component version metadata
-    std::optional<std::string> title;                 ///< Human-readable title
+    std::optional<std::string> version; ///< Component version metadata
+    std::optional<std::string> title;   ///< Human-readable title
     std::optional<std::string> description;
     std::optional<std::string> mimeType;
     std::optional<fastmcpp::Json> annotations;
@@ -221,8 +221,8 @@ struct PromptArgument
 struct PromptInfo
 {
     std::string name;
-    std::optional<std::string> version;               ///< Component version metadata
-    std::optional<std::string> title;                 ///< Human-readable title
+    std::optional<std::string> version; ///< Component version metadata
+    std::optional<std::string> title;   ///< Human-readable title
     std::optional<std::string> description;
     std::optional<std::vector<PromptArgument>> arguments;
     std::optional<std::vector<fastmcpp::Icon>> icons; ///< Icons for UI display

include/fastmcpp/providers/transforms/catalog.hpp

@@ -61,8 +61,7 @@ class CatalogTransform : public Transform
 
     // ---- Subclass hooks (override these, not list_*) ----
 
-    virtual std::vector<tools::Tool>
-    transform_tools(const ListToolsNext& call_next) const
+    virtual std::vector<tools::Tool> transform_tools(const ListToolsNext& call_next) const
     {
         return call_next();
     }
@@ -79,8 +78,7 @@ class CatalogTransform : public Transform
         return call_next();
     }
 
-    virtual std::vector<prompts::Prompt>
-    transform_prompts(const ListPromptsNext& call_next) const
+    virtual std::vector<prompts::Prompt> transform_prompts(const ListPromptsNext& call_next) const
     {
         return call_next();
     }
@@ -123,15 +121,13 @@ class CatalogTransform : public Transform
         return result;
     }
 
-    std::vector<resources::Resource>
-    get_resource_catalog(const ListResourcesNext& call_next) const
+    std::vector<resources::Resource> get_resource_catalog(const ListResourcesNext& call_next) const
     {
         BypassGuard guard(bypass_);
         return call_next();
     }
 
-    std::vector<prompts::Prompt>
-    get_prompt_catalog(const ListPromptsNext& call_next) const
+    std::vector<prompts::Prompt> get_prompt_catalog(const ListPromptsNext& call_next) const
     {
         BypassGuard guard(bypass_);
         return call_next();