runtime_interposition_controller.h

#pragma once
 
#include <neograph/api.h>
#include <neograph/controlled_provider.h>
#include <neograph/runtime_turn_assembler.h>
#include <neograph/hook_runtime.h>
#include <neograph/graph/provider_call_broker.h>
 
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace neograph {
 
class NEOGRAPH_API RuntimeInterpositionController final {
public:
    RuntimeInterpositionController(std::shared_ptr<Provider> provider,
                                   std::shared_ptr<ContextStore> context_store,
                                    std::shared_ptr<ProviderDispatchReceiptStore> dispatch_store,
                                    std::string provider_binding_identity,
                                    std::uint64_t max_input_tokens = 0,
                                    std::vector<std::string> static_required_skill_artifact_ids = {});
    RuntimeInterpositionController(
        std::shared_ptr<Provider> provider,
        std::shared_ptr<ContextStore> context_store,
        std::shared_ptr<ProviderDispatchReceiptStore> dispatch_store,
        std::string provider_binding_identity,
        RuntimeContextRequirements requirements,
        std::uint64_t max_input_tokens);
    ~RuntimeInterpositionController();
    RuntimeInterpositionController(RuntimeInterpositionController&&) noexcept;
    RuntimeInterpositionController& operator=(RuntimeInterpositionController&&) noexcept;
    RuntimeInterpositionController(const RuntimeInterpositionController&) = delete;
    RuntimeInterpositionController& operator=(const RuntimeInterpositionController&) = delete;
 
    void activate(std::string owner_id, ContextEpoch epoch);
    void activate(std::string owner_id, ContextEpoch epoch,
                  std::optional<ContextEpoch> predecessor);
    void clear() noexcept;
    bool active() const noexcept;
    void set_hook_runtime(std::shared_ptr<HookRuntime> hooks);
 
    asio::awaitable<sp::runtime::Result> invoke_async(
        ProviderRequest request,
        std::vector<sp::Message> host_instructions = {},
        std::vector<sp::Message> trusted_supplemental = {},
        graph::ProviderCallIdentity identity = {});
    sp::runtime::Result invoke(
        ProviderRequest request, graph::ProviderCallIdentity identity = {});
 
private:
    struct Impl;
    std::shared_ptr<Impl> impl_;
};
 
}  // namespace neograph