runtime_turn_assembler.h

#pragma once
 
#include <neograph/api.h>
#include <neograph/provider.h>
#include <neograph/context_store.h>
#include <neograph/runtime_context.h>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph {
 
class NEOGRAPH_API ContextBudgetBlocked final : public std::runtime_error {
public:
    ContextBudgetBlocked();
};
 
struct NEOGRAPH_API RuntimeTurn {
    PreparedProviderRequest request;
    ContextAssemblyReceipt assembly_receipt;
};
 
struct RuntimeContextRequirements {
    std::vector<std::string> required_artifact_ids;
    std::vector<std::string> required_skill_artifact_ids;
};
 
class NEOGRAPH_API RuntimeTurnAssembler final {
public:
    RuntimeTurnAssembler(ContextStore& store,
                          std::vector<std::string> static_required_skill_artifact_ids = {},
                          std::uint64_t max_input_tokens = 0);
    RuntimeTurnAssembler(ContextStore& store,
                         std::uint64_t max_input_tokens,
                         RuntimeContextRequirements requirements);
    ~RuntimeTurnAssembler();
    RuntimeTurnAssembler(RuntimeTurnAssembler&&) noexcept;
    RuntimeTurnAssembler& operator=(RuntimeTurnAssembler&&) noexcept;
    RuntimeTurnAssembler(const RuntimeTurnAssembler&) = delete;
    RuntimeTurnAssembler& operator=(const RuntimeTurnAssembler&) = delete;
 
    RuntimeTurn assemble(Provider& provider, std::string owner_id,
                          const ContextEpoch& epoch,
                          ProviderRequest request) const;
    RuntimeTurn assemble(Provider& provider, std::string owner_id,
                         const ContextEpoch& epoch,
                         ProviderRequest request,
                         std::vector<sp::Message> host_instructions,
                         std::vector<sp::Message> trusted_supplemental) const;
 
    static std::uint64_t estimate_input_tokens(const PreparedProviderRequest& request);
    static std::string normalized_request_digest(const PreparedProviderRequest& request);
    static std::optional<std::string> tools_digest(std::string_view encoded_body);
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace neograph