program_adapter.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/a2a/collaboration.h>
#include <neograph/a2a/types.h>
#include <neograph/program/runtime.h>
 
#include <functional>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph::a2a {
 
class NEOGRAPH_API ProgramA2ARequestError final : public std::runtime_error {
public:
    explicit ProgramA2ARequestError(std::string message)
        : std::runtime_error(std::move(message)) {}
};
 
class NEOGRAPH_API ProgramAgentAdapter final {
public:
    using InvocationBuilder = std::function<program::RunInvocation(
        const Message&, std::string_view task_id, std::string_view context_id)>;
    using ArtifactBuilder = std::function<std::optional<Artifact>(
        const program::ProgramResult&, std::string_view task_id)>;
    using HostMessageHandler = std::function<std::optional<Task>(
        const Message&, std::string_view task_id, std::string_view context_id,
        const std::optional<CollaborationPeerIdentity>& authenticated_peer)>;
 
    ProgramAgentAdapter(std::shared_ptr<program::ProgramRuntime> runtime,
                         program::ProgramVersion version,
                         std::string owner_scope,
                         std::shared_ptr<CollaborationMailbox> mailbox = {},
                         InvocationBuilder invocation_builder = {},
                         ArtifactBuilder artifact_builder = {},
                         HostMessageHandler host_message_handler = {});
 
    const std::string& owner_scope() const noexcept;
    const program::ProgramVersion& version() const noexcept;
    const std::shared_ptr<program::ProgramRuntime>& runtime() const noexcept;
    const std::shared_ptr<CollaborationMailbox>& mailbox() const noexcept;
    std::optional<Task> handle_host_message(
        const Message& inbound, std::string_view task_id,
        std::string_view context_id,
        const std::optional<CollaborationPeerIdentity>& authenticated_peer) const;
 
    program::ProgramHandle start(const Message& inbound,
                                 std::string_view task_id,
                                 std::string_view context_id) const;
 
    std::vector<program::ProgramHandle> recover_pending() const;
 
    program::ProgramHandle reconnect(std::string_view task_id) const;
 
    Task task_snapshot(const program::ProgramHandle& handle,
                       std::string_view task_id,
                       std::string_view context_id) const;
 
    Task reconnect_task(std::string_view task_id,
                        std::string_view context_id = {}) const;
 
    void acknowledge_task(std::string_view task_id) const;
 
private:
    program::ProgramHandle recover_record(const CollaborationRecord& record) const;
    std::shared_ptr<program::ProgramRuntime> runtime_;
    program::ProgramVersion                 version_;
    std::string                             owner_scope_;
    std::shared_ptr<CollaborationMailbox>   mailbox_;
    InvocationBuilder                       invocation_builder_;
    ArtifactBuilder                         artifact_builder_;
    HostMessageHandler                      host_message_handler_;
};
 
using ProgramA2AAdapter = ProgramAgentAdapter;
 
}  // namespace neograph::a2a