Add tool-call request/response types

Author: bandoti

toolcall/mcp_messages.cpp

@@ -280,6 +280,82 @@ mcp::tools_list_response mcp::tools_list_response::fromJson(const nlohmann::json
     return tools_list_response(j["id"], std::move(tools), next_cursor);
 }
 
+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))
+{
+    refreshParams();
+}
+
+void mcp::tools_call_request::name(std::string name) {
+    name_ = std::move(name);
+    refreshParams();
+}
+
+void mcp::tools_call_request::args(mcp::tool_arg_list args) {
+    args_ = std::move(args);
+    refreshParams();
+}
+
+void mcp::tools_call_request::refreshParams() {
+    json params = json::object();
+    params["name"] = name_;
+    if (! args_.empty()) {
+        json args = json::object();
+        for (const auto & arg : args_) {
+            args[arg.name] = arg.value;
+        }
+        params["arguments"] = args;
+    }
+    this->params(params);
+}
+
+mcp::tools_call_response::tools_call_response(nlohmann::json id, tool_result_list result, bool error)
+    : response(id), tool_result_(std::move(result)), error_(error)
+{
+    refreshResult();
+}
+
+void mcp::tools_call_response::tool_result(mcp::tool_result_list result) {
+    tool_result_ = std::move(result);
+    refreshResult();
+}
+
+void mcp::tools_call_response::tool_error(bool error) {
+    error_ = error;
+    refreshResult();
+}
+
+void mcp::tools_call_response::refreshResult() {
+    json result = json::object();
+    result["isError"] = error_;
+    json content = json::array();
+    for (const auto & res : tool_result_) {
+        json r;
+        r["type"] = res.type;
+        if (res.type == "text") {
+            r["text"] = res.value;
+
+        } else if (res.type == "image" || res.type == "audio") {
+            r["data"] = res.value;
+            r["mimeType"] = res.mime_type.value(); // throws
+
+        } else if (res.type == "resource") {
+            json rr;
+            rr["uri"] = res.uri.value(); // throws
+            rr["mimeType"] = res.mime_type.value(); //throws
+            rr["text"] = res.value;
+
+            r["resource"] = rr;
+
+        } else {
+            // throw
+        }
+        content.push_back(r);
+    }
+    result["content"] = content;
+    this->result(std::move(result));
+}
+
 static bool has_initialized_response(const nlohmann::json & data) {
     return data["result"].contains("capabilities");
 }

toolcall/mcp_messages.h

@@ -222,14 +222,64 @@ namespace mcp
             : notification("notifications/tools/list_changed") {}
     };
 
+    struct tool_arg {
+        std::string name;
+        std::string value;
+    };
+
+    using tool_arg_list = std::vector<tool_arg>;
+
+    class tools_call_request : public request {
+    public:
+        tools_call_request(nlohmann::json id, std::string name, tool_arg_list args = tool_arg_list());
+
+        void name(std::string name);
+        const std::string & name() const { return name_; }
+
+        void args(tool_arg_list args);
+        const tool_arg_list args() const { return args_; }
+
+    private:
+        void refreshParams();
+        std::string name_;
+        tool_arg_list args_;
+    };
+
+    struct tool_result {
+        std::string type; // text, image, audio, or resource
+        std::string value;
+        std::optional<std::string> mime_type; // Only for: image, audio, and resource
+        std::optional<std::string> uri;       // Only for: resource
+    };
+
+    using tool_result_list = std::vector<tool_result>;
+
+    class tools_call_response : public response {
+    public:
+        tools_call_response(nlohmann::json id, tool_result_list result = tool_result_list(), bool error = false);
+
+        void tool_result(tool_result_list result);
+        const tool_result_list & tool_result() const { return tool_result_; }
+
+        void tool_error(bool error);
+        bool tool_error() const { return error_; }
+
+    private:
+        void refreshResult();
+        tool_result_list tool_result_;
+        bool error_;
+    };
+
     using message_variant =
         std::variant<std::monostate,
                      initialize_request,
                      initialize_response,
                      initialized_notification,
                      tools_list_request,
                      tools_list_response,
-                     tools_list_changed_notification>;
+                     tools_list_changed_notification,
+                     tools_call_request,
+                     tools_call_response>;
 
     bool create_message(const std::string & data, message_variant & message);
 }