external_client.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/mcp/transport.h>
 
#include <atomic>
#include <cstdint>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
namespace entropic {
 
class ExternalMCPClient {
public:
    ExternalMCPClient(std::string name,
                      std::unique_ptr<Transport> transport);
 
    bool connect();
 
    void set_init_timeout_ms(uint32_t ms);
 
    void disconnect();
 
    std::string list_tools() const;
 
    std::string execute(const std::string& tool_name,
                        const std::string& args_json);
 
    std::pair<std::vector<std::string>, std::vector<std::string>>
    refresh_tools();
 
    bool is_connected() const;
 
    const std::string& name() const { return name_; }
 
    void interrupt() { if (transport_) { transport_->interrupt(); } }
 
    void clear_interrupt() { if (transport_) { transport_->clear_interrupt(); } }
 
    bool is_interrupted() const {
        return transport_ && transport_->is_interrupted();
    }
 
private:
    std::string name_;                           
    std::unique_ptr<Transport> transport_;        
    std::string cached_tools_json_;              
    std::vector<std::string> cached_tool_names_; 
    mutable std::mutex tools_mutex_;             
    std::atomic<int> next_id_{1};
 
    static constexpr uint32_t DEFAULT_TIMEOUT_MS = 30000; 
    static constexpr uint32_t INIT_TIMEOUT_MS = 10000;    
    uint32_t init_timeout_ms_ = INIT_TIMEOUT_MS;
 
    std::string build_request(const std::string& method,
                              const std::string& params = "{}");
 
    std::string build_request_id(const std::string& method,
                                 const std::string& params,
                                 int& id);
 
    static bool response_matches(const std::string& response_json,
                                 int expected_id);
 
    bool send_initialize();
 
    bool validate_init_response(const std::string& response);
 
    bool query_tools();
 
    static std::string extract_tool_result(
        const std::string& response_json);
 
    std::string empty_response_envelope(
        const std::string& tool_name) const;
 
    std::string mismatched_response_envelope(
        const std::string& tool_name, int expected_id) const;
 
    std::string response_problem(const std::string& tool_name,
                                 const std::string& response,
                                 int expected_id) const;
 
    static std::string build_response(const std::string& result_text,
                                       bool is_error = false);
};
 
} // namespace entropic