client.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/a2a/types.h>
 
#include <asio/awaitable.hpp>
 
#include <chrono>
#include <functional>
#include <memory>
#include <atomic>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <string>
 
namespace neograph::graph { class CancelToken; }
 
namespace neograph::a2a {
 
#ifdef NEOGRAPH_A2A_TESTING
namespace test { class A2AClientTestAccess; }
#endif
 
class NEOGRAPH_API A2ARpcError : public std::runtime_error {
  public:
    A2ARpcError(int code, const std::string& what)
        : std::runtime_error(what), code_(code) {}
    int code() const noexcept { return code_; }
 
  private:
    int code_;
};
 
class NEOGRAPH_API A2AClient {
  public:
    explicit A2AClient(std::string base_url);
 
    void set_timeout(std::chrono::seconds t);
 
    void set_connect_timeout(std::chrono::seconds t);
 
    void set_allow_cross_origin_interfaces(bool allow);
 
    std::optional<WireDialect> wire_dialect() const;
 
    void set_authorization_header(std::string authorization_header);
 
    AgentCard fetch_agent_card(bool force = false);
 
    asio::awaitable<AgentCard> fetch_agent_card_async(bool force = false);
 
    Task send_message_sync(
        const std::string& text,
        const std::string& task_id    = "",
        const std::string& context_id = "",
        graph::CancelToken* cancel    = nullptr);
 
    Task send_message_sync(const MessageSendParams& params,
                           graph::CancelToken* cancel = nullptr);
 
    asio::awaitable<Task> send_message_async(const MessageSendParams& params);
 
    Task get_task(const std::string& task_id, int history_length = 0);
    asio::awaitable<Task> get_task_async(const std::string& task_id, int history_length = 0);
 
    Task cancel_task(const std::string& task_id);
    asio::awaitable<Task> cancel_task_async(const std::string& task_id);
 
    using EventCallback = std::function<bool(const StreamEvent&)>;
 
    Task send_message_stream(const std::string& text,
                             EventCallback on_event,
                             const std::string& task_id    = "",
                             const std::string& context_id = "");
 
    Task send_message_stream(const MessageSendParams& params,
                             EventCallback on_event);
 
    json rpc_call(const std::string& method, const json& params,
                  std::optional<WireDialect> dialect = std::nullopt);
    asio::awaitable<json> rpc_call_async(
        const std::string& method, const json& params,
        std::optional<WireDialect> dialect = std::nullopt);
 
    const std::string& base_url() const { return base_url_; }
 
    std::string endpoint_url() const;
 
  private:
#ifdef NEOGRAPH_A2A_TESTING
    friend class test::A2AClientTestAccess;
#endif
    std::string base_url_;
    std::chrono::seconds timeout_ = std::chrono::seconds(0);          // 0 = no whole-exchange bound
    std::chrono::seconds connect_timeout_ = std::chrono::seconds(30); // 0 = no connect bound
    std::atomic<int> request_id_{0};
 
    mutable std::shared_ptr<std::mutex> state_mutex_ = std::make_shared<std::mutex>();
    bool card_loading_ = false;
 
    AgentCard cached_card_;
    bool      card_loaded_ = false;
    bool      card_unavailable_ = false;
    bool      allow_cross_origin_ = false;
    std::string authorization_header_;
 
    struct Selection {
        WireDialect dialect = WireDialect::V0_3;
        std::string tenant;
        std::string url;   
    };
    std::optional<Selection> selection_;
 
    std::optional<Selection> resolve_selection();
    asio::awaitable<std::optional<Selection>> select_async();
    void remember_probe(WireDialect dialect);
 
    asio::awaitable<json> post_rpc(const std::string& url, const std::string& method,
                                   const json& params, std::optional<WireDialect> dialect);
 
    asio::awaitable<json> call_method(
        const char* v1_method, const char* v03_method,
        const std::function<json(WireDialect, const std::string& tenant)>& build);
 
    Task stream_once(WireDialect dialect, const std::string& tenant, const std::string& url,
                     const MessageSendParams& params, const EventCallback& on_event,
                     bool& saw_events);
 
    std::string request_authorization_header() const;
 
    std::chrono::seconds request_timeout() const;
    std::chrono::seconds request_connect_timeout() const;
};
 
} // namespace neograph::a2a