Add tools_call_response fromJson

Author: bandoti

toolcall/handler.cpp

@@ -107,15 +107,15 @@ void toolcall::mcp_impl::initialize() {
 
     on_list_changed update_dirty = [&update_dirty, this] (const mcp::tools_list_changed_notification &) {
         tool_list_dirty_ = true;
-        transport_->subscribe("notifications/tools/list_changed", update_dirty);
+        transport_->subscribe(update_dirty);
     };
 
     bool has_tools = false;
     for (const auto & cap : caps) {
         if (cap.name == "tools") {
             has_tools = true;
             if (cap.listChanged) {
-                transport_->subscribe("notifications/tools/list_changed", update_dirty);
+                transport_->subscribe(update_dirty);
             }
             break;
         }

toolcall/mcp_messages.cpp

@@ -181,7 +181,7 @@ mcp::initialize_response mcp::initialize_response::fromJson(const nlohmann::json
 }
 
 mcp::tools_list_request::tools_list_request(std::optional<nlohmann::json> id, std::string cursor)
-    : request(id, "tools/list"),
+    : request(id, Method),
       cursor_(std::move(cursor))
 {
     refreshParams();
@@ -282,15 +282,14 @@ mcp::tools_list_response mcp::tools_list_response::fromJson(const nlohmann::json
 }
 
 mcp::tools_list_changed_notification mcp::tools_list_changed_notification::fromJson(const nlohmann::json & j) {
-    if (! (j.is_object() && j.contains("method") &&
-           j["method"] == "notifications/tools/list_changed")) {
+    if (! (j.is_object() && j.contains("method") && j["method"] == Method)) {
         throw std::invalid_argument("Invalid tools_list_changed message");
     }
     return tools_list_changed_notification();
 }
 
 mcp::tools_call_request::tools_call_request(nlohmann::json id, std::string name, tool_arg_list args)
-    : request(id, "tools/call"), name_(std::move(name)), args_(std::move(args))
+    : request(id, Method), name_(std::move(name)), args_(std::move(args))
 {
     refreshParams();
 }
@@ -364,3 +363,30 @@ void mcp::tools_call_response::refreshResult() {
     result["content"] = content;
     this->result(std::move(result));
 }
+
+mcp::tools_call_response mcp::tools_call_response::fromJson(const nlohmann::json & j) {
+    mcp::tool_result_list result_list;
+    for (const auto & content : j["result"]["content"]) {
+        mcp::tool_result result;
+
+        result.type = content["type"];
+        if (content["type"] == "text") {
+            result.value = content["text"];
+
+        } else if (content["type"] == "image" || content["type"] == "audio") {
+            result.value = content["data"];
+            result.mime_type = content["mimeType"];
+
+        } else if (content["type"] == "resource") {
+            result.value = content["resource"]["text"];
+            result.mime_type = content["resource"]["mimeType"];
+            result.uri = content["resource"]["uri"];
+        }
+
+        result_list.push_back(std::move(result));
+    }
+
+    bool error = j["result"].value("isError", false);
+
+    return mcp::tools_call_response(j["id"], std::move(result_list), error);
+}

toolcall/mcp_messages.h

@@ -166,12 +166,15 @@ namespace mcp
 
     class initialized_notification : public notification {
     public:
-        initialized_notification()
-            : notification("notifications/initialized") {}
+        static inline const std::string Method = "notifications/initialized";
+
+        initialized_notification() : notification(Method) {}
     };
 
     class tools_list_request : public request {
     public:
+        static inline const std::string Method = "tools/list";
+
         tools_list_request(std::optional<nlohmann::json> id, std::string cursor = "");
 
         void cursor(std::string cursor);
@@ -218,8 +221,9 @@ namespace mcp
 
     class tools_list_changed_notification : public notification {
     public:
-        tools_list_changed_notification()
-            : notification("notifications/tools/list_changed") {}
+        static inline const std::string Method = "notifications/tools/list_changed";
+
+        tools_list_changed_notification() : notification(Method) {}
 
         static tools_list_changed_notification fromJson(const nlohmann::json & j);
     };
@@ -233,6 +237,8 @@ namespace mcp
 
     class tools_call_request : public request {
     public:
+        static inline const std::string Method = "tools/call";
+
         tools_call_request(nlohmann::json id, std::string name, tool_arg_list args = tool_arg_list());
 
         void name(std::string name);
@@ -266,6 +272,8 @@ namespace mcp
         void tool_error(bool error);
         bool tool_error() const { return error_; }
 
+        static tools_call_response fromJson(const nlohmann::json & j);
+
     private:
         void refreshResult();
         tool_result_list tool_result_;

toolcall/mcp_transport.h

@@ -22,6 +22,15 @@ namespace toolcall
             map.insert({key, callback});
         }
 
+	template <typename T>
+	void subscribe(callback<T> callback) {
+	    auto& map =
+                std::get<std::map<std::string, toolcall::callback<T>>>(
+                    subscribers_);
+
+	    map.insert({T::Method, callback});
+	}
+
         template <typename T>
         void unsubscribe(std::string key) {
             auto& map =
@@ -62,7 +71,8 @@ namespace toolcall
 
     class mcp_transport : public mcp_message_observer<mcp::initialize_response,
                                                       mcp::tools_list_response,
-                                                      mcp::tools_list_changed_notification> {
+                                                      mcp::tools_list_changed_notification,
+                                                      mcp::tools_call_response> {
     public:
         virtual ~mcp_transport() = default;