Fix clang-format styling for tasks/elicitation code

Author: 0xeb

examples/context_elicitation.cpp

@@ -108,8 +108,7 @@ int main()
 
     std::cout << "[server] Calling Context::elicit()...\n\n";
 
-    ElicitationResult result =
-        ctx.elicit("Please confirm your profile information:", base_schema);
+    ElicitationResult result = ctx.elicit("Please confirm your profile information:", base_schema);
 
     if (auto* accepted = std::get_if<AcceptedElicitation>(&result))
     {
@@ -128,4 +127,3 @@ int main()
     std::cout << "=== Example Complete ===\n";
     return 0;
 }
-

examples/sse_elicitation_server.cpp

@@ -17,8 +17,8 @@
 #include "fastmcpp/app.hpp"
 #include "fastmcpp/mcp/handler.hpp"
 #include "fastmcpp/server/context.hpp"
-#include "fastmcpp/server/sse_server.hpp"
 #include "fastmcpp/server/session.hpp"
+#include "fastmcpp/server/sse_server.hpp"
 #include "fastmcpp/tools/manager.hpp"
 #include "fastmcpp/util/json.hpp"
 
@@ -29,11 +29,11 @@
 #include <string>
 #include <thread>
 
-using fastmcpp::Json;
 using fastmcpp::FastMCP;
+using fastmcpp::Json;
 using fastmcpp::server::Context;
-using fastmcpp::server::SseServerWrapper;
 using fastmcpp::server::ServerSession;
+using fastmcpp::server::SseServerWrapper;
 
 static std::atomic<bool> g_running{true};
 
@@ -79,23 +79,21 @@ int main(int argc, char* argv[])
         Json{{"type", "object"},
              {"properties",
               Json{{"prompt",
-                    Json{{"type", "string"},
-                         {"description", "Prompt to display to the user"}}}}},
+                    Json{{"type", "string"}, {"description", "Prompt to display to the user"}}}}},
              {"required", Json::array({"prompt"})}},
         Json{{"type", "object"},
-             {"properties",
-              Json{{"name", Json{{"type", "string"}}},
-                   {"age", Json{{"type", "integer"}}},
-                   {"newsletter", Json{{"type", "boolean"}}}}},
+             {"properties", Json{{"name", Json{{"type", "string"}}},
+                                 {"age", Json{{"type", "integer"}}},
+                                 {"newsletter", Json{{"type", "boolean"}}}}},
              {"required", Json::array({"name", "age"})}},
         // Tool implementation; actual elicitation wiring is done in the MCP handler
         [](const Json& args) -> Json
         {
             // This body will be replaced by the MCP handler's Context-based path.
             // If invoked directly, just echo the prompt for debugging.
             std::string prompt = args.value("prompt", std::string("Please fill in your profile"));
-            return Json{{"content",
-                        Json::array({Json{{"type", "text"}, {"text", "Prompt: " + prompt}}})}};
+            return Json{
+                {"content", Json::array({Json{{"type", "text"}, {"text", "Prompt: " + prompt}}})}};
         }};
 
     app.tools().register_tool(ask_user_profile);
@@ -141,9 +139,7 @@ int main(int argc, char* argv[])
             }
 
             if (method == "ping")
-            {
                 return Json{{"jsonrpc", "2.0"}, {"id", id}, {"result", Json::object()}};
-            }
 
             if (method == "tools/list")
             {
@@ -154,9 +150,8 @@ int main(int argc, char* argv[])
                     Json entry = {{"name", tool.name()}, {"inputSchema", tool.input_schema()}};
                     tools_array.push_back(entry);
                 }
-                return Json{{"jsonrpc", "2.0"},
-                            {"id", id},
-                            {"result", Json{{"tools", tools_array}}}};
+                return Json{
+                    {"jsonrpc", "2.0"}, {"id", id}, {"result", Json{{"tools", tools_array}}}};
             }
 
             if (method == "tools/call")
@@ -165,10 +160,10 @@ int main(int argc, char* argv[])
                 Json args = params.value("arguments", Json::object());
                 if (name.empty())
                 {
-                    return Json{{"jsonrpc", "2.0"},
-                                {"id", id},
-                                {"error",
-                                 Json{{"code", -32602}, {"message", "Missing tool name"}}}};
+                    return Json{
+                        {"jsonrpc", "2.0"},
+                        {"id", id},
+                        {"error", Json{{"code", -32602}, {"message", "Missing tool name"}}}};
                 }
 
                 if (name == "ask_user_profile")
@@ -203,13 +198,11 @@ int main(int argc, char* argv[])
                     if (!ctx.has_elicitation())
                     {
                         // No client-side elicitation support; degrade gracefully.
-                        Json content = Json::array({Json{
-                            {"type", "text"},
-                            {"text",
-                             "Elicitation not available; prompt was: " + prompt}}});
-                        return Json{{"jsonrpc", "2.0"},
-                                    {"id", id},
-                                    {"result", Json{{"content", content}}}};
+                        Json content = Json::array(
+                            {Json{{"type", "text"},
+                                  {"text", "Elicitation not available; prompt was: " + prompt}}});
+                        return Json{
+                            {"jsonrpc", "2.0"}, {"id", id}, {"result", Json{{"content", content}}}};
                     }
 
                     auto result = ctx.elicit(prompt, base_schema);
@@ -218,9 +211,9 @@ int main(int argc, char* argv[])
                     if (auto* accepted =
                             std::get_if<fastmcpp::server::AcceptedElicitation>(&result))
                     {
-                        content.push_back(Json{
-                            {"type", "text"},
-                            {"text", std::string("User profile: ") + accepted->data.dump()}});
+                        content.push_back(
+                            Json{{"type", "text"},
+                                 {"text", std::string("User profile: ") + accepted->data.dump()}});
                     }
                     else if (std::holds_alternative<fastmcpp::server::DeclinedElicitation>(result))
                     {
@@ -233,9 +226,8 @@ int main(int argc, char* argv[])
                             Json{{"type", "text"}, {"text", "User cancelled elicitation"}});
                     }
 
-                    return Json{{"jsonrpc", "2.0"},
-                                {"id", id},
-                                {"result", Json{{"content", content}}}};
+                    return Json{
+                        {"jsonrpc", "2.0"}, {"id", id}, {"result", Json{{"content", content}}}};
                 }
 
                 // Fallback: direct FastMCP invoke_tool
@@ -246,21 +238,19 @@ int main(int argc, char* argv[])
                 else if (result.is_array())
                     content = result;
                 else if (result.is_string())
-                    content = Json::array(
-                        {Json{{"type", "text"}, {"text", result.get<std::string>()}}});
+                    content =
+                        Json::array({Json{{"type", "text"}, {"text", result.get<std::string>()}}});
                 else
                     content = Json::array({Json{{"type", "text"}, {"text", result.dump()}}});
 
-                return Json{{"jsonrpc", "2.0"},
-                            {"id", id},
-                            {"result", Json{{"content", content}}}};
+                return Json{{"jsonrpc", "2.0"}, {"id", id}, {"result", Json{{"content", content}}}};
             }
 
-            return Json{{"jsonrpc", "2.0"},
-                        {"id", id},
-                        {"error",
-                         Json{{"code", -32601},
-                              {"message", std::string("Method '") + method + "' not found"}}}};
+            return Json{
+                {"jsonrpc", "2.0"},
+                {"id", id},
+                {"error", Json{{"code", -32601},
+                               {"message", std::string("Method '") + method + "' not found"}}}};
         }
         catch (const std::exception& e)
         {

include/fastmcpp/client/client.hpp

@@ -333,9 +333,8 @@ class Client
     /// @param arguments Tool arguments
     /// @param ttl_ms Time to keep results available in milliseconds (hint to server)
     /// @return Shared pointer to ToolTask wrapper
-    std::shared_ptr<ToolTask>
-    call_tool_task(const std::string& name, const fastmcpp::Json& arguments,
-                   int ttl_ms = 60000);
+    std::shared_ptr<ToolTask> call_tool_task(const std::string& name,
+                                             const fastmcpp::Json& arguments, int ttl_ms = 60000);
 
     /// Query status of a background task via MCP 'tasks/get'.
     /// @throws fastmcpp::Error if server does not support tasks or returns error
@@ -424,8 +423,7 @@ class Client
     /// that polls 'tasks/get' and 'tasks/result'. When the server executes
     /// synchronously (no task support), ResourceTask wraps the immediate
     /// contents result.
-    std::shared_ptr<ResourceTask> read_resource_task(const std::string& uri,
-                                                     int ttl_ms = 60000);
+    std::shared_ptr<ResourceTask> read_resource_task(const std::string& uri, int ttl_ms = 60000);
 
     // ==========================================================================
     // Prompt Operations
@@ -479,8 +477,7 @@ class Client
     /// synchronously (no task support), PromptTask wraps the immediate result.
     std::shared_ptr<PromptTask>
     get_prompt_task(const std::string& name,
-                    const fastmcpp::Json& arguments = fastmcpp::Json::object(),
-                    int ttl_ms = 60000);
+                    const fastmcpp::Json& arguments = fastmcpp::Json::object(), int ttl_ms = 60000);
 
     // ==========================================================================
     // Completion Operations
@@ -1058,8 +1055,7 @@ class ToolTask
     /// Wait until the task reaches the desired state or timeout elapses.
     /// If timeout_ms == 0, waits until terminal state.
     TaskStatus wait(const std::string& desired_state = "completed",
-                    std::chrono::milliseconds timeout_ms =
-                        std::chrono::milliseconds(60000)) const
+                    std::chrono::milliseconds timeout_ms = std::chrono::milliseconds(60000)) const
     {
         auto start = std::chrono::steady_clock::now();
 
@@ -1069,8 +1065,7 @@ class ToolTask
             if (s.status == desired_state || s.status == "failed" || s.status == "cancelled")
                 return s;
 
-            if (timeout_ms.count() > 0 &&
-                std::chrono::steady_clock::now() - start >= timeout_ms)
+            if (timeout_ms.count() > 0 && std::chrono::steady_clock::now() - start >= timeout_ms)
                 return s;
 
             int poll_ms = s.pollInterval.value_or(1000);
@@ -1140,17 +1135,16 @@ class ToolTask
     inline static std::atomic<uint64_t> next_synthetic_id_{0};
 };
 
-inline std::shared_ptr<ToolTask>
-Client::call_tool_task(const std::string& name, const fastmcpp::Json& arguments, int ttl_ms)
+inline std::shared_ptr<ToolTask> Client::call_tool_task(const std::string& name,
+                                                        const fastmcpp::Json& arguments, int ttl_ms)
 {
     CallToolOptions opts;
     opts.timeout = std::chrono::milliseconds{0};
     opts.progress_handler = nullptr;
 
     // Attach task metadata in _meta (mirrors Python fastmcp)
     fastmcpp::Json task_meta = {{"ttl", ttl_ms}};
-    opts.meta = fastmcpp::Json{
-        {"modelcontextprotocol.io/task", std::move(task_meta)}};
+    opts.meta = fastmcpp::Json{{"modelcontextprotocol.io/task", std::move(task_meta)}};
 
     auto result = call_tool_mcp(name, arguments, opts);
 
@@ -1222,8 +1216,7 @@ class PromptTask
     }
 
     TaskStatus wait(const std::string& desired_state = "completed",
-                    std::chrono::milliseconds timeout_ms =
-                        std::chrono::milliseconds(60000)) const
+                    std::chrono::milliseconds timeout_ms = std::chrono::milliseconds(60000)) const
     {
         auto start = std::chrono::steady_clock::now();
 
@@ -1233,8 +1226,7 @@ class PromptTask
             if (s.status == desired_state || s.status == "failed" || s.status == "cancelled")
                 return s;
 
-            if (timeout_ms.count() > 0 &&
-                std::chrono::steady_clock::now() - start >= timeout_ms)
+            if (timeout_ms.count() > 0 && std::chrono::steady_clock::now() - start >= timeout_ms)
                 return s;
 
             int poll_ms = s.pollInterval.value_or(1000);
@@ -1280,8 +1272,7 @@ class ResourceTask
   public:
     ResourceTask(Client* client, std::string task_id, std::string uri,
                  std::optional<std::vector<ResourceContent>> immediate_contents)
-        : client_(client), uri_(std::move(uri)),
-          immediate_contents_(std::move(immediate_contents))
+        : client_(client), uri_(std::move(uri)), immediate_contents_(std::move(immediate_contents))
     {
         if (!client_)
             throw fastmcpp::Error("ResourceTask requires non-null client");
@@ -1326,8 +1317,7 @@ class ResourceTask
     }
 
     TaskStatus wait(const std::string& desired_state = "completed",
-                    std::chrono::milliseconds timeout_ms =
-                        std::chrono::milliseconds(60000)) const
+                    std::chrono::milliseconds timeout_ms = std::chrono::milliseconds(60000)) const
     {
         auto start = std::chrono::steady_clock::now();
 
@@ -1337,8 +1327,7 @@ class ResourceTask
             if (s.status == desired_state || s.status == "failed" || s.status == "cancelled")
                 return s;
 
-            if (timeout_ms.count() > 0 &&
-                std::chrono::steady_clock::now() - start >= timeout_ms)
+            if (timeout_ms.count() > 0 && std::chrono::steady_clock::now() - start >= timeout_ms)
                 return s;
 
             int poll_ms = s.pollInterval.value_or(1000);
@@ -1377,32 +1366,27 @@ class ResourceTask
     inline static std::atomic<uint64_t> next_synthetic_id_{0};
 };
 
-inline std::shared_ptr<ResourceTask>
-Client::read_resource_task(const std::string& uri, int ttl_ms)
+inline std::shared_ptr<ResourceTask> Client::read_resource_task(const std::string& uri, int ttl_ms)
 {
     fastmcpp::Json payload = {{"uri", uri}};
 
     fastmcpp::Json task_meta = {{"ttl", ttl_ms}};
-    payload["_meta"] = fastmcpp::Json{
-        {"modelcontextprotocol.io/task", std::move(task_meta)}};
+    payload["_meta"] = fastmcpp::Json{{"modelcontextprotocol.io/task", std::move(task_meta)}};
 
     auto response = call("resources/read", payload);
 
-    if (response.contains("_meta") &&
-        response["_meta"].contains("modelcontextprotocol.io/task"))
+    if (response.contains("_meta") && response["_meta"].contains("modelcontextprotocol.io/task"))
     {
         const auto& task_obj = response["_meta"]["modelcontextprotocol.io/task"];
         if (task_obj.contains("taskId"))
         {
             std::string task_id = task_obj["taskId"].get<std::string>();
-            return std::make_shared<ResourceTask>(this, std::move(task_id), uri,
-                                                  std::nullopt);
+            return std::make_shared<ResourceTask>(this, std::move(task_id), uri, std::nullopt);
         }
     }
 
     ReadResourceResult result = parse_read_resource_result(response);
-    return std::make_shared<ResourceTask>(this, std::string{}, uri,
-                                          std::move(result.contents));
+    return std::make_shared<ResourceTask>(this, std::string{}, uri, std::move(result.contents));
 }
 
 inline std::shared_ptr<PromptTask>
@@ -1421,20 +1405,17 @@ Client::get_prompt_task(const std::string& name, const fastmcpp::Json& arguments
     }
 
     fastmcpp::Json task_meta = {{"ttl", ttl_ms}};
-    payload["_meta"] = fastmcpp::Json{
-        {"modelcontextprotocol.io/task", std::move(task_meta)}};
+    payload["_meta"] = fastmcpp::Json{{"modelcontextprotocol.io/task", std::move(task_meta)}};
 
     auto response = call("prompts/get", payload);
 
-    if (response.contains("_meta") &&
-        response["_meta"].contains("modelcontextprotocol.io/task"))
+    if (response.contains("_meta") && response["_meta"].contains("modelcontextprotocol.io/task"))
     {
         const auto& task_obj = response["_meta"]["modelcontextprotocol.io/task"];
         if (task_obj.contains("taskId"))
         {
             std::string task_id = task_obj["taskId"].get<std::string>();
-            return std::make_shared<PromptTask>(this, std::move(task_id), name,
-                                                std::nullopt);
+            return std::make_shared<PromptTask>(this, std::move(task_id), name, std::nullopt);
         }
     }
 

include/fastmcpp/server/context.hpp

@@ -1,9 +1,9 @@
 #pragma once
 #include "fastmcpp/prompts/prompt.hpp"
 #include "fastmcpp/resources/resource.hpp"
-#include "fastmcpp/types.hpp"
 #include "fastmcpp/server/elicitation.hpp"
 #include "fastmcpp/server/session.hpp"
+#include "fastmcpp/types.hpp"
 
 #include <any>
 #include <functional>
@@ -85,7 +85,8 @@ struct CancelledElicitation
 {
 };
 
-using ElicitationResult = std::variant<AcceptedElicitation, DeclinedElicitation, CancelledElicitation>;
+using ElicitationResult =
+    std::variant<AcceptedElicitation, DeclinedElicitation, CancelledElicitation>;
 
 /// Callback type for elicitation: takes user-facing message and elicitation schema,
 /// returns an ElicitationResult describing the user response.
@@ -104,8 +105,8 @@ make_elicitation_callback(std::shared_ptr<ServerSession> session,
     if (!session)
         return {};
 
-    return [session, related_request_id,
-            timeout](const std::string& message, const fastmcpp::Json& schema) -> ElicitationResult
+    return [session, related_request_id, timeout](const std::string& message,
+                                                  const fastmcpp::Json& schema) -> ElicitationResult
     {
         fastmcpp::Json params = {{"message", message}, {"requestedSchema", schema}};
         if (related_request_id && !related_request_id->empty())