server.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/a2a/types.h>
#include <neograph/graph/execution.h>
 
#ifdef NEOGRAPH_A2A_PROGRAM
#include <neograph/a2a/collaboration.h>
#include <neograph/a2a/program_adapter.h>
#endif
 
#include <chrono>
#include <functional>
#include <cstddef>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#ifdef NEOGRAPH_A2A_PROGRAM
namespace neograph::program {
class ProgramRuntime;
class ProgramVersion;
}  // namespace neograph::program
#endif
 
namespace neograph::a2a {
 
#ifdef NEOGRAPH_A2A_PROGRAM
class ProgramAgentAdapter;
#endif
 
#ifdef NEOGRAPH_A2A_TESTING
namespace test { class A2AServerTestAccess; }
#endif
 
class NEOGRAPH_API GraphAgentAdapter {
  public:
    virtual ~GraphAgentAdapter() = default;
 
    virtual std::string input_channel() const { return "prompt"; }
 
    virtual std::string output_channel() const { return "response"; }
 
    virtual neograph::json build_initial_state(const std::string& user_text) const;
 
    virtual std::optional<Artifact> build_output_artifact(
        const neograph::json& output,
        const std::string& task_id) const;
 
    virtual neograph::json build_resume_value(const Message& message) const;
};
 
class NEOGRAPH_API StructuredOutputAdapter final : public GraphAgentAdapter {
  public:
    StructuredOutputAdapter(std::string contract,
                            int version,
                            std::string data_channel,
                            std::string input_channel = "prompt");
 
    std::string input_channel() const override;
    std::string output_channel() const override;
    std::optional<Artifact> build_output_artifact(
        const neograph::json& output,
        const std::string& task_id) const override;
 
  private:
    std::string contract_;
    int         version_;
    std::string data_channel_;
    std::string input_channel_;
};
 
struct NEOGRAPH_API A2AHttpConfig {
    std::vector<std::string> allowed_origins;
 
    std::vector<std::string> allowed_hosts;
 
    std::size_t max_payload_bytes = 4 * 1024 * 1024;
};
 
class NEOGRAPH_API A2AServer {
  public:
    A2AServer(std::shared_ptr<neograph::graph::GraphEngine> engine,
              AgentCard card,
              std::shared_ptr<GraphAgentAdapter> adapter = {});
    A2AServer(neograph::graph::GraphExecution execution,
              AgentCard card,
              std::shared_ptr<GraphAgentAdapter> adapter = {});
 
#ifdef NEOGRAPH_A2A_PROGRAM
 
    using CollaborationAuthenticator = std::function<std::optional<CollaborationPeerIdentity>(
        std::string_view authorization_header)>;
 
    A2AServer(std::shared_ptr<ProgramAgentAdapter> adapter,
              AgentCard card,
              CollaborationAuthenticator collaboration_authenticator = {},
              bool require_authenticated_requests = false);
 
    A2AServer(std::shared_ptr<neograph::program::ProgramRuntime> runtime,
              neograph::program::ProgramVersion version,
              std::string owner_scope,
              AgentCard card,
              std::shared_ptr<CollaborationMailbox> mailbox = {},
              CollaborationAuthenticator collaboration_authenticator = {},
              bool require_authenticated_requests = false);
    A2AServer(std::shared_ptr<neograph::program::ProgramRuntime> runtime,
              neograph::program::ProgramVersion version,
              AgentCard card,
              std::string owner_scope,
              std::shared_ptr<CollaborationMailbox> mailbox = {},
              CollaborationAuthenticator collaboration_authenticator = {},
              bool require_authenticated_requests = false);
#endif
 
    ~A2AServer();
 
    bool start(const std::string& host, int port);
 
    bool start_async(const std::string& host, int port);
 
    void stop();
 
    bool is_running() const;
 
    int port() const;
 
    void set_http_config(A2AHttpConfig config);
 
    void set_trust_forwarded_headers(bool enabled);
 
  private:
#ifdef NEOGRAPH_A2A_TESTING
    friend class test::A2AServerTestAccess;
#endif
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace neograph::a2a
 
#ifdef NEOGRAPH_A2A_TESTING
namespace neograph::a2a::test {
 
class A2AServerTestAccess {
  public:
    static void set_max_inflight_runs(A2AServer& server, std::size_t cap);
    static void set_stream_keepalive(A2AServer& server, std::chrono::milliseconds interval);
    static void set_stream_handoff_hook(A2AServer& server, std::function<void()> hook);
    static bool draining(const A2AServer& server);
};
 
}  // namespace neograph::a2a::test
#endif