server.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/acp/types.h>
#include <neograph/graph/engine.h>
 
#include <chrono>
#include <iosfwd>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
 
namespace neograph::acp {
 
class ACPServer;
 
class NEOGRAPH_API ACPGraphAdapter {
  public:
    virtual ~ACPGraphAdapter() = default;
 
    virtual std::string input_channel() const { return "prompt"; }
 
    virtual std::string output_channel() const { return "response"; }
 
    virtual std::string extract_user_text(
        const std::vector<ContentBlock>& blocks) const;
 
    virtual neograph::json build_initial_state(
        const std::vector<ContentBlock>& blocks,
        const std::string& session_id) const;
 
    virtual std::string extract_agent_text(
        const neograph::json& output) const;
};
 
class NEOGRAPH_API ACPClient {
  public:
    ACPClient();
 
    explicit ACPClient(ACPServer* server);
 
    void bind(ACPServer* server);
 
    bool bound() const noexcept;
 
    void set_timeout(std::chrono::milliseconds t);
 
    std::string read_text_file(std::string_view session_id,
                               std::string_view path,
                               std::optional<int> line  = {},
                               std::optional<int> limit = {});
 
    void write_text_file(std::string_view session_id,
                         std::string_view path,
                         std::string_view content);
 
    RequestPermissionOutcome request_permission(
        std::string_view session_id,
        const ToolCallUpdate&  tool_call,
        const std::vector<PermissionOption>& options);
 
  private:
    ACPServer*               server_ = nullptr;
    std::chrono::milliseconds timeout_{std::chrono::seconds(30)};
};
 
class NEOGRAPH_API ACPServer {
  public:
    using NotificationSink = std::function<void(const neograph::json&)>;
 
    ACPServer(std::shared_ptr<neograph::graph::GraphEngine> engine,
              neograph::json info,
              std::shared_ptr<ACPGraphAdapter> adapter = {});
 
    ~ACPServer();
 
    AgentCapabilities&       capabilities();
    const AgentCapabilities& capabilities() const;
 
    void run(std::istream& in, std::ostream& out);
 
    void run();
 
    bool is_running() const;
 
    neograph::json handle_message(const neograph::json& envelope);
 
    void set_notification_sink(NotificationSink sink);
 
    void stop();
 
    bool initialized() const;
 
    std::shared_ptr<ACPClient> client();
 
    void attach_client(std::shared_ptr<ACPClient> c);
 
    neograph::json call_client(std::string method,
                                neograph::json params,
                                std::chrono::milliseconds timeout
                                    = std::chrono::seconds(30));
 
  private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace neograph::acp