transport_sse.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/mcp/transport.h>
 
#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
 
namespace httplib { class Client; }
 
namespace entropic {
 
class SSETransport : public Transport {
public:
    explicit SSETransport(std::string url,
                          uint32_t default_timeout_ms = 30000);
 
    ~SSETransport() override;
 
    bool open() override;
 
    void close() override;
 
    std::string send_request(
        const std::string& request_json,
        uint32_t timeout_ms = 0) override;
 
    bool is_connected() const override;
 
private:
    std::string url_;                            
    std::string host_;                           
    std::string sse_path_;                       
    std::string message_endpoint_;               
    uint32_t default_timeout_ms_;                
 
    std::unique_ptr<httplib::Client> client_;    
    std::atomic<bool> connected_{false};         
    std::atomic<bool> running_{false};           
    std::thread sse_reader_thread_;              
 
    std::mutex pending_mutex_;                   
    std::condition_variable pending_cv_;          
    std::map<int, std::string> pending_responses_; 
    std::atomic<int> next_request_id_{1};        
 
    bool parse_url();
 
    void warn_if_cleartext() const;
 
    static bool parse_request_id(
        const std::string& request_json, int& request_id);
 
    bool post_request(const std::string& request_json);
 
    std::string await_response(int request_id, uint32_t timeout_ms);
 
    void sse_reader_loop();
 
    void handle_sse_data(const std::string& data);
 
    void handle_endpoint_event(const std::string& data);
 
    void process_sse_line(const std::string& line);
 
    std::string current_event_type_;  
};
 
} // namespace entropic