Store callbacks in map

Author: bandoti

toolcall/handler.cpp

@@ -100,13 +100,13 @@ void toolcall::mcp_impl::initialize() {
         tools_populating_.notify_one();
     };
 
-    transport_->subscribe(set_caps);
+    transport_->subscribe("set_caps", set_caps);
 
     mcp::initialize_request req(next_id_++);
     transport_->send(req.toJson());
 
     tools_populating_.wait_for(lock, std::chrono::seconds(15));
-    transport_->unsubscribe(set_caps);
+    transport_->unsubscribe<mcp::initialize_response>("set_caps");
 
     on_list_changed update_dirty = [this] (const mcp::tools_list_changed_notification &) {
         tool_list_dirty_ = true;
@@ -117,7 +117,7 @@ void toolcall::mcp_impl::initialize() {
         if (cap.name == "tools") {
             has_tools = true;
             if (cap.listChanged) {
-                transport_->subscribe(update_dirty);
+                transport_->subscribe("update_dirty", update_dirty);
             }
             break;
         }
@@ -153,13 +153,13 @@ std::string toolcall::mcp_impl::tool_list() {
             tools_populating_.notify_one();
         };
 
-        transport_->subscribe(set_tools);
+        transport_->subscribe("set_tools", set_tools);
 
         mcp::tools_list_request req(std::to_string(next_id_++));
         transport_->send(req.toJson());
 
         tools_populating_.wait_for(lock, std::chrono::seconds(15));
-        transport_->unsubscribe(set_tools);
+        transport_->unsubscribe<mcp::tools_list_response>("set_tools");
 
         tools_ = tools_list_to_oai_json(tools);
     }

toolcall/mcp_transport.h

@@ -3,7 +3,7 @@
 #include "mcp_messages.h"
 #include <string>
 #include <tuple>
-#include <vector>
+#include <map>
 
 namespace toolcall
 {
@@ -13,27 +13,32 @@ namespace toolcall
     template <typename Derived, typename... MessageTypes>
     class mcp_transport_t {
     public:
-
         template <typename T>
-        void subscribe(callback<T> callback) {
-            auto& vec = std::get<std::vector<toolcall::callback<T>>>(subscribers_);
-            vec.push_back(std::move(callback));
+        void subscribe(std::string key, callback<T> callback) {
+            auto& map =
+                std::get<std::map<std::string, toolcall::callback<T>>>(
+                    subscribers_);
+
+            map.insert({key, callback});
         }
 
         template <typename T>
-        void unsubscribe(callback<T> callback) {
-            auto& vec = std::get<std::vector<toolcall::callback<T>>>(subscribers_);
-            auto found = std::find(vec.begin(), vec.end(), callback);
-            if (found != vec.end()) {
-                vec.erase(found);
-            }
+        void unsubscribe(std::string key) {
+            auto& map =
+                std::get<std::map<std::string, toolcall::callback<T>>>(
+                    subscribers_);
+
+            map.erase(key);
         }
 
         template <typename T>
         void notify(const T & message) const {
-            const auto& vec = std::get<std::vector<toolcall::callback<T>>>(subscribers_);
-            for (const auto& callback : vec) {
-                callback(message);
+            const auto& map =
+                std::get<std::map<std::string, toolcall::callback<T>>>(
+                    subscribers_);
+
+            for (const auto & pair : map) {
+                pair.second(message);
             }
         }
 
@@ -50,7 +55,7 @@ namespace toolcall
         }
 
     private:
-        std::tuple<std::vector<toolcall::callback<MessageTypes>>...> subscribers_;
+        std::tuple<std::map<std::string, toolcall::callback<MessageTypes>>...> subscribers_;
     };
 
     class mcp_transport : public mcp_transport_t <mcp_transport,