style: apply clang-format

0xeb · 0xeb · commit bcde26ee7cd5 · 2025-12-30T10:13:33.000-08:00
diff --git a/include/fastmcpp/client/client.hpp b/include/fastmcpp/client/client.hpp
@@ -59,7 +59,8 @@ class IResettableTransport
 using ServerRequestHandler =
     std::function<fastmcpp::Json(const std::string& method, const fastmcpp::Json& params)>;
 
-/// Optional transport interface: some transports can accept server-initiated requests and send responses.
+/// Optional transport interface: some transports can accept server-initiated requests and send
+/// responses.
 class IServerRequestTransport
 {
   public:
@@ -663,7 +664,7 @@ class Client
     }
 
     /// Register roots/sampling/elicitation callbacks (placeholders for parity)
-    void set_roots_callback(const std::function<fastmcpp::Json()>& cb)    
+    void set_roots_callback(const std::function<fastmcpp::Json()>& cb)
     {
         set_roots_callback_impl(cb);
     }
@@ -714,7 +715,7 @@ class Client
     };
 
     std::shared_ptr<CallbackState> callbacks_;
-    std::unordered_map<std::string, fastmcpp::Json> tool_output_schemas_; 
+    std::unordered_map<std::string, fastmcpp::Json> tool_output_schemas_;
 
     std::function<fastmcpp::Json()> get_roots_callback() const
     {
@@ -745,16 +746,15 @@ class Client
         std::lock_guard<std::mutex> lock(callbacks_->mutex);
         callbacks_->roots_callback = cb;
     }
-    void set_sampling_callback_impl(
-        const std::function<fastmcpp::Json(const fastmcpp::Json&)>& cb)
+    void set_sampling_callback_impl(const std::function<fastmcpp::Json(const fastmcpp::Json&)>& cb)
     {
         if (!callbacks_)
             callbacks_ = std::make_shared<CallbackState>();
         std::lock_guard<std::mutex> lock(callbacks_->mutex);
         callbacks_->sampling_callback = cb;
     }
-    void set_elicitation_callback_impl(
-        const std::function<fastmcpp::Json(const fastmcpp::Json&)>& cb)
+    void
+    set_elicitation_callback_impl(const std::function<fastmcpp::Json(const fastmcpp::Json&)>& cb)
     {
         if (!callbacks_)
             callbacks_ = std::make_shared<CallbackState>();
@@ -811,7 +811,8 @@ class Client
     }
 
     // Internal constructor for cloning
-    Client(std::shared_ptr<ITransport> t, std::shared_ptr<CallbackState> callbacks, bool /*internal*/)
+    Client(std::shared_ptr<ITransport> t, std::shared_ptr<CallbackState> callbacks,
+           bool /*internal*/)
         : transport_(std::move(t)), callbacks_(std::move(callbacks))
     {
         configure_transport_callbacks();
diff --git a/include/fastmcpp/client/sampling.hpp b/include/fastmcpp/client/sampling.hpp
@@ -22,15 +22,14 @@ using SamplingHandlerResult = std::variant<std::string, fastmcpp::Json>;
 using SamplingHandler = std::function<SamplingHandlerResult(const fastmcpp::Json& params)>;
 
 /// Build a minimal MCP CreateMessageResult with a single text content block.
-inline fastmcpp::Json make_text_result(std::string text,
-                                      std::string model = "fastmcpp-client",
-                                      std::string role = "assistant")
+inline fastmcpp::Json make_text_result(std::string text, std::string model = "fastmcpp-client",
+                                       std::string role = "assistant")
 {
     return fastmcpp::Json{
         {"role", std::move(role)},
         {"model", std::move(model)},
-        {"content", fastmcpp::Json::array(
-                        {fastmcpp::Json{{"type", "text"}, {"text", std::move(text)}}})},
+        {"content",
+         fastmcpp::Json::array({fastmcpp::Json{{"type", "text"}, {"text", std::move(text)}}})},
     };
 }
 
@@ -49,4 +48,3 @@ create_sampling_callback(SamplingHandler handler)
 }
 
 } // namespace fastmcpp::client::sampling
-
diff --git a/include/fastmcpp/client/transports.hpp b/include/fastmcpp/client/transports.hpp
@@ -96,7 +96,9 @@ class StdioTransport : public ITransport
 /// 1. Client connects to /sse endpoint (GET) to establish event stream
 /// 2. Client sends JSON-RPC requests to /messages endpoint (POST)
 /// 3. Server sends JSON-RPC responses back via the SSE stream
-class SseClientTransport : public ITransport, public IServerRequestTransport, public IResettableTransport
+class SseClientTransport : public ITransport,
+                           public IServerRequestTransport,
+                           public IResettableTransport
 {
   public:
     /// Construct an SSE client transport
@@ -121,7 +123,7 @@ class SseClientTransport : public ITransport, public IServerRequestTransport, pu
     /// Check if a session ID has been set.
     bool has_session() const;
 
-    void set_server_request_handler(ServerRequestHandler handler) override;     
+    void set_server_request_handler(ServerRequestHandler handler) override;
 
     void reset(bool full = false) override;
 
diff --git a/include/fastmcpp/client/types.hpp b/include/fastmcpp/client/types.hpp
@@ -343,7 +343,7 @@ inline void from_json(const fastmcpp::Json& j, ToolInfo& t)
         t.title = j["title"].get<std::string>();
     if (j.contains("description"))
         t.description = j["description"].get<std::string>();
-    t.inputSchema = j.value("inputSchema", fastmcpp::Json::object());     
+    t.inputSchema = j.value("inputSchema", fastmcpp::Json::object());
     if (j.contains("outputSchema"))
         t.outputSchema = j["outputSchema"];
     if (j.contains("execution"))
@@ -389,7 +389,7 @@ inline void from_json(const fastmcpp::Json& j, ResourceInfo& r)
         r._meta = j["_meta"];
 }
 
-inline void to_json(fastmcpp::Json& j, const ResourceTemplate& t)        
+inline void to_json(fastmcpp::Json& j, const ResourceTemplate& t)
 {
     j = fastmcpp::Json{{"uriTemplate", t.uriTemplate}, {"name", t.name}};
     if (t.title)
@@ -406,7 +406,7 @@ inline void to_json(fastmcpp::Json& j, const ResourceTemplate& t)
         j["_meta"] = *t._meta;
 }
 
-inline void from_json(const fastmcpp::Json& j, ResourceTemplate& t)       
+inline void from_json(const fastmcpp::Json& j, ResourceTemplate& t)
 {
     t.uriTemplate = j.at("uriTemplate").get<std::string>();
     t.name = j.at("name").get<std::string>();
diff --git a/src/client/transports.cpp b/src/client/transports.cpp
@@ -708,7 +708,7 @@ void SseClientTransport::start_sse_listener()
 
                     if (!aggregated.empty())
                     {
-                        // Handle endpoint event specially - it's not JSON      
+                        // Handle endpoint event specially - it's not JSON
                         if (event_type == "endpoint")
                         {
                             std::lock_guard<std::mutex> lock(endpoint_mutex_);
@@ -721,9 +721,9 @@ void SseClientTransport::start_sse_listener()
                             {
                                 pos += std::string("session_id=").size();
                                 auto end = endpoint_path_.find_first_of("&#", pos);
-                                session_id_ = endpoint_path_.substr(
-                                    pos, end == std::string::npos ? std::string::npos
-                                                              : (end - pos));
+                                session_id_ = endpoint_path_.substr(pos, end == std::string::npos
+                                                                             ? std::string::npos
+                                                                             : (end - pos));
                             }
                         }
                         else
@@ -919,7 +919,7 @@ fastmcpp::Json SseClientTransport::request(const std::string& route, const fastm
     cli.set_connection_timeout(5, 0);
     cli.set_read_timeout(30, 0);
 
-    // Use the endpoint path from SSE if available, otherwise use default       
+    // Use the endpoint path from SSE if available, otherwise use default
     std::string post_path;
     {
         std::lock_guard<std::mutex> lock(endpoint_mutex_);
diff --git a/tests/server/interactions_part2b.cpp b/tests/server/interactions_part2b.cpp
@@ -904,7 +904,7 @@ void test_tool_meta_custom_fields()
     std::cout << "Test: tool list with meta fields...\n";
 
     auto srv = create_meta_variations_server();
-    client::Client c(std::make_unique<client::LoopbackTransport>(srv));   
+    client::Client c(std::make_unique<client::LoopbackTransport>(srv));
 
     // Test that list_tools_mcp can access list-level _meta
     auto result = c.list_tools_mcp();
@@ -959,7 +959,7 @@ void test_resource_meta_fields()
     std::cout << "Test: resource with meta fields...\n";
 
     auto srv = create_meta_variations_server();
-    client::Client c(std::make_unique<client::LoopbackTransport>(srv));   
+    client::Client c(std::make_unique<client::LoopbackTransport>(srv));
 
     auto resources = c.list_resources();
     bool found = false;
diff --git a/tests/server/sse_bidirectional_requests.cpp b/tests/server/sse_bidirectional_requests.cpp
@@ -28,7 +28,9 @@ Json make_result_response(const Json& request_id, Json result)
 
 Json make_error_response(const Json& request_id, int code, const std::string& message)
 {
-    return Json{{"jsonrpc", "2.0"}, {"id", request_id}, {"error", Json{{"code", code}, {"message", message}}}};
+    return Json{{"jsonrpc", "2.0"},
+                {"id", request_id},
+                {"error", Json{{"code", code}, {"message", message}}}};
 }
 } // namespace
 
@@ -101,8 +103,8 @@ int main()
 
     std::this_thread::sleep_for(500ms);
 
-    auto transport = std::make_unique<fastmcpp::client::SseClientTransport>(
-        "http://127.0.0.1:" + std::to_string(port));
+    auto transport = std::make_unique<fastmcpp::client::SseClientTransport>("http://127.0.0.1:" +
+                                                                            std::to_string(port));
     auto* sse_transport = transport.get();
     fastmcpp::client::Client client(std::move(transport));
 
@@ -178,7 +180,8 @@ int main()
     Json result;
     try
     {
-        result = session->send_request("sampling/createMessage", params, std::chrono::milliseconds(5000));
+        result = session->send_request("sampling/createMessage", params,
+                                       std::chrono::milliseconds(5000));
     }
     catch (const std::exception& e)
     {
@@ -201,7 +204,8 @@ int main()
     }
     if (result.value("model", std::string()) != "fastmcpp-client")
     {
-        std::cerr << "Unexpected model in sampling response: " << result.value("model", std::string()) << "\n";
+        std::cerr << "Unexpected model in sampling response: "
+                  << result.value("model", std::string()) << "\n";
         sse_server->stop();
         return 1;
     }
diff --git a/tests/server/streamable_http_integration.cpp b/tests/server/streamable_http_integration.cpp
@@ -238,7 +238,8 @@ void test_session_management()
         transport.request("initialize", init_params);
         assert(transport.has_session() && "Should have session after re-initialize");
         assert(transport.session_id() != session_id && "Session ID should change after reset");
-        assert(server.session_count() == 2 && "Server should have 2 sessions after reset + initialize");
+        assert(server.session_count() == 2 &&
+               "Server should have 2 sessions after reset + initialize");
 
         std::cout << "PASSED\n";
     }

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,8 @@ class IResettableTransport`
`59`	`59`	`using ServerRequestHandler =`
`60`	`60`	`std::function<fastmcpp::Json(const std::string& method, const fastmcpp::Json& params)>;`
`61`	`61`
`62`		`-/// Optional transport interface: some transports can accept server-initiated requests and send responses.`
	`62`	`+/// Optional transport interface: some transports can accept server-initiated requests and send`
	`63`	`+/// responses.`
`63`	`64`	`class IServerRequestTransport`
`64`	`65`	`{`
`65`	`66`	`public:`
`@@ -663,7 +664,7 @@ class Client`
`663`	`664`	`}`
`664`	`665`
`665`	`666`	`/// Register roots/sampling/elicitation callbacks (placeholders for parity)`
`666`		`- void set_roots_callback(const std::function<fastmcpp::Json()>& cb)`
	`667`	`+ void set_roots_callback(const std::function<fastmcpp::Json()>& cb)`
`667`	`668`	`{`
`668`	`669`	`set_roots_callback_impl(cb);`
`669`	`670`	`}`
`@@ -714,7 +715,7 @@ class Client`
`714`	`715`	`};`
`715`	`716`
`716`	`717`	`std::shared_ptr<CallbackState> callbacks_;`
`717`		`- std::unordered_map<std::string, fastmcpp::Json> tool_output_schemas_;`
	`718`	`+ std::unordered_map<std::string, fastmcpp::Json> tool_output_schemas_;`
`718`	`719`
`719`	`720`	`std::function<fastmcpp::Json()> get_roots_callback() const`
`720`	`721`	`{`
`@@ -745,16 +746,15 @@ class Client`
`745`	`746`	`std::lock_guard<std::mutex> lock(callbacks_->mutex);`
`746`	`747`	`callbacks_->roots_callback = cb;`
`747`	`748`	`}`
`748`		`- void set_sampling_callback_impl(`
`749`		`- const std::function<fastmcpp::Json(const fastmcpp::Json&)>& cb)`
	`749`	`+ void set_sampling_callback_impl(const std::function<fastmcpp::Json(const fastmcpp::Json&)>& cb)`
`750`	`750`	`{`
`751`	`751`	`if (!callbacks_)`
`752`	`752`	`callbacks_ = std::make_shared<CallbackState>();`
`753`	`753`	`std::lock_guard<std::mutex> lock(callbacks_->mutex);`
`754`	`754`	`callbacks_->sampling_callback = cb;`
`755`	`755`	`}`
`756`		`- void set_elicitation_callback_impl(`
`757`		`- const std::function<fastmcpp::Json(const fastmcpp::Json&)>& cb)`
	`756`	`+ void`
	`757`	`+ set_elicitation_callback_impl(const std::function<fastmcpp::Json(const fastmcpp::Json&)>& cb)`
`758`	`758`	`{`
`759`	`759`	`if (!callbacks_)`
`760`	`760`	`callbacks_ = std::make_shared<CallbackState>();`
`@@ -811,7 +811,8 @@ class Client`
`811`	`811`	`}`
`812`	`812`
`813`	`813`	`// Internal constructor for cloning`
`814`		`- Client(std::shared_ptr<ITransport> t, std::shared_ptr<CallbackState> callbacks, bool /internal/)`
	`814`	`+ Client(std::shared_ptr<ITransport> t, std::shared_ptr<CallbackState> callbacks,`
	`815`	`+ bool /internal/)`
`815`	`816`	`: transport_(std::move(t)), callbacks_(std::move(callbacks))`
`816`	`817`	`{`
`817`	`818`	`configure_transport_callbacks();`
Original file line number	Diff line number	Diff line change
`@@ -343,7 +343,7 @@ inline void from_json(const fastmcpp::Json& j, ToolInfo& t)`
`343`	`343`	`t.title = j["title"].get<std::string>();`
`344`	`344`	`if (j.contains("description"))`
`345`	`345`	`t.description = j["description"].get<std::string>();`
`346`		`- t.inputSchema = j.value("inputSchema", fastmcpp::Json::object());`
	`346`	`+ t.inputSchema = j.value("inputSchema", fastmcpp::Json::object());`
`347`	`347`	`if (j.contains("outputSchema"))`
`348`	`348`	`t.outputSchema = j["outputSchema"];`
`349`	`349`	`if (j.contains("execution"))`
`@@ -389,7 +389,7 @@ inline void from_json(const fastmcpp::Json& j, ResourceInfo& r)`
`389`	`389`	`r._meta = j["_meta"];`
`390`	`390`	`}`
`391`	`391`
`392`		`-inline void to_json(fastmcpp::Json& j, const ResourceTemplate& t)`
	`392`	`+inline void to_json(fastmcpp::Json& j, const ResourceTemplate& t)`
`393`	`393`	`{`
`394`	`394`	`j = fastmcpp::Json{{"uriTemplate", t.uriTemplate}, {"name", t.name}};`
`395`	`395`	`if (t.title)`
`@@ -406,7 +406,7 @@ inline void to_json(fastmcpp::Json& j, const ResourceTemplate& t)`
`406`	`406`	`j["_meta"] = *t._meta;`
`407`	`407`	`}`
`408`	`408`
`409`		`-inline void from_json(const fastmcpp::Json& j, ResourceTemplate& t)`
	`409`	`+inline void from_json(const fastmcpp::Json& j, ResourceTemplate& t)`
`410`	`410`	`{`
`411`	`411`	`t.uriTemplate = j.at("uriTemplate").get<std::string>();`
`412`	`412`	`t.name = j.at("name").get<std::string>();`
Original file line number	Diff line number	Diff line change
`@@ -708,7 +708,7 @@ void SseClientTransport::start_sse_listener()`
`708`	`708`
`709`	`709`	`if (!aggregated.empty())`
`710`	`710`	`{`
`711`		`- // Handle endpoint event specially - it's not JSON`
	`711`	`+ // Handle endpoint event specially - it's not JSON`
`712`	`712`	`if (event_type == "endpoint")`
`713`	`713`	`{`
`714`	`714`	`std::lock_guard<std::mutex> lock(endpoint_mutex_);`
`@@ -721,9 +721,9 @@ void SseClientTransport::start_sse_listener()`
`721`	`721`	`{`
`722`	`722`	`pos += std::string("session_id=").size();`
`723`	`723`	`auto end = endpoint_path_.find_first_of("&#", pos);`
`724`		`- session_id_ = endpoint_path_.substr(`
`725`		`- pos, end == std::string::npos ? std::string::npos`
`726`		`- : (end - pos));`
	`724`	`+ session_id_ = endpoint_path_.substr(pos, end == std::string::npos`
	`725`	`+ ? std::string::npos`
	`726`	`+ : (end - pos));`
`727`	`727`	`}`
`728`	`728`	`}`
`729`	`729`	`else`
`@@ -919,7 +919,7 @@ fastmcpp::Json SseClientTransport::request(const std::string& route, const fastm`
`919`	`919`	`cli.set_connection_timeout(5, 0);`
`920`	`920`	`cli.set_read_timeout(30, 0);`
`921`	`921`
`922`		`- // Use the endpoint path from SSE if available, otherwise use default`
	`922`	`+ // Use the endpoint path from SSE if available, otherwise use default`
`923`	`923`	`std::string post_path;`
`924`	`924`	`{`
`925`	`925`	`std::lock_guard<std::mutex> lock(endpoint_mutex_);`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,9 @@ Json make_result_response(const Json& request_id, Json result)`
`28`	`28`
`29`	`29`	`Json make_error_response(const Json& request_id, int code, const std::string& message)`
`30`	`30`	`{`
`31`		`- return Json{{"jsonrpc", "2.0"}, {"id", request_id}, {"error", Json{{"code", code}, {"message", message}}}};`
	`31`	`+ return Json{{"jsonrpc", "2.0"},`
	`32`	`+ {"id", request_id},`
	`33`	`+ {"error", Json{{"code", code}, {"message", message}}}};`
`32`	`34`	`}`
`33`	`35`	`} // namespace`
`34`	`36`
`@@ -101,8 +103,8 @@ int main()`
`101`	`103`
`102`	`104`	`std::this_thread::sleep_for(500ms);`
`103`	`105`
`104`		`- auto transport = std::make_unique<fastmcpp::client::SseClientTransport>(`
`105`		`- "http://127.0.0.1:" + std::to_string(port));`
	`106`	`+ auto transport = std::make_unique<fastmcpp::client::SseClientTransport>("http://127.0.0.1:" +`
	`107`	`+ std::to_string(port));`
`106`	`108`	`auto* sse_transport = transport.get();`
`107`	`109`	`fastmcpp::client::Client client(std::move(transport));`
`108`	`110`
`@@ -178,7 +180,8 @@ int main()`
`178`	`180`	`Json result;`
`179`	`181`	`try`
`180`	`182`	`{`
`181`		`- result = session->send_request("sampling/createMessage", params, std::chrono::milliseconds(5000));`
	`183`	`+ result = session->send_request("sampling/createMessage", params,`
	`184`	`+ std::chrono::milliseconds(5000));`
`182`	`185`	`}`
`183`	`186`	`catch (const std::exception& e)`
`184`	`187`	`{`
`@@ -201,7 +204,8 @@ int main()`
`201`	`204`	`}`
`202`	`205`	`if (result.value("model", std::string()) != "fastmcpp-client")`
`203`	`206`	`{`
`204`		`- std::cerr << "Unexpected model in sampling response: " << result.value("model", std::string()) << "\n";`
	`207`	`+ std::cerr << "Unexpected model in sampling response: "`
	`208`	`+ << result.value("model", std::string()) << "\n";`
`205`	`209`	`sse_server->stop();`
`206`	`210`	`return 1;`
`207`	`211`	`}`
Original file line number	Diff line number	Diff line change
`@@ -238,7 +238,8 @@ void test_session_management()`
`238`	`238`	`transport.request("initialize", init_params);`
`239`	`239`	`assert(transport.has_session() && "Should have session after re-initialize");`
`240`	`240`	`assert(transport.session_id() != session_id && "Session ID should change after reset");`
`241`		`- assert(server.session_count() == 2 && "Server should have 2 sessions after reset + initialize");`
	`241`	`+ assert(server.session_count() == 2 &&`
	`242`	`+ "Server should have 2 sessions after reset + initialize");`
`242`	`243`
`243`	`244`	`std::cout << "PASSED\n";`
`244`	`245`	`}`