registry.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/registry.h>
#include <neograph/json.h>
#include <neograph/program/native.h>
 
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph::program {
 
namespace detail {
class RegistrySnapshotAccess;
}
 
enum class EffectMode : std::uint8_t {
    Brokered,
    TrustedNative,
};
 
NEOGRAPH_PROGRAM_API std::string_view to_string(EffectMode mode) noexcept;
NEOGRAPH_PROGRAM_API EffectMode       effect_mode_from_string(std::string_view value);
 
struct ExecutableManifest {
    ExecutableIdentity              identity;
    EffectMode                      effect_mode = EffectMode::Brokered;
    std::string                     attestation_id;  // host declaration id; not a signature
    std::vector<std::string>        required_capabilities;
    std::vector<std::string>        declared_effects;
    std::vector<ExecutableIdentity> required_executables;
    ExecutionGuarantee              execution_guarantee = ExecutionGuarantee::Strict;
};
 
struct ProviderMetadata {
    json request_schema;
    json response_schema;
};
 
struct ToolMetadata {
    json input_schema;
    json output_schema;
};
 
struct ImportedExecutableMetadata {
    std::string        module_id;
    std::string        export_name;
    std::string        dependency_digest;
    ExecutableIdentity target;
};
using ExecutableRequirementResolver =
    std::function<std::vector<ExecutableIdentity>(const json& node_config)>;
 
class NEOGRAPH_PROGRAM_API RegistrySnapshot {
public:
    RegistrySnapshot(const RegistrySnapshot&) noexcept            = default;
    RegistrySnapshot(RegistrySnapshot&&) noexcept                 = default;
    RegistrySnapshot& operator=(const RegistrySnapshot&) noexcept = default;
    RegistrySnapshot& operator=(RegistrySnapshot&&) noexcept      = default;
    ~RegistrySnapshot();
 
    const std::string&                fingerprint() const noexcept;
    std::vector<ExecutableIdentity>   identities() const;
    std::optional<ExecutableManifest> find(ExecutableKind kind, std::string_view name) const;
    json                              manifest() const;
    std::optional<NativeControlBinding> find_native(std::string_view name) const;
    std::string                       serialize_canonical() const;
 
private:
    struct Impl;
    std::shared_ptr<const Impl> impl_;
 
    explicit RegistrySnapshot(std::shared_ptr<const Impl> impl);
    friend class RegistrySnapshotBuilder;
    friend class detail::RegistrySnapshotAccess;
};
 
class NEOGRAPH_PROGRAM_API RegistrySnapshotBuilder {
public:
    RegistrySnapshotBuilder();
    RegistrySnapshotBuilder(RegistrySnapshotBuilder&&) noexcept;
    RegistrySnapshotBuilder& operator=(RegistrySnapshotBuilder&&) noexcept;
    RegistrySnapshotBuilder(const RegistrySnapshotBuilder&)            = delete;
    RegistrySnapshotBuilder& operator=(const RegistrySnapshotBuilder&) = delete;
    ~RegistrySnapshotBuilder();
 
    RegistrySnapshotBuilder& add_node(
        ExecutableManifest            manifest,
        graph::NodeFactoryFn          factory,
        json                          config_schema,
        json                          effects,
        ExecutableRequirementResolver requirement_resolver = {});
    RegistrySnapshotBuilder& add_host_brokered_node(
        ExecutableManifest            manifest,
        graph::NodeFactoryFn          factory,
        json                          config_schema,
        json                          effects,
        ExecutableRequirementResolver requirement_resolver = {});
    RegistrySnapshotBuilder& add_core_llm_call(
        ExecutableManifest manifest,
        ExecutableRequirementResolver requirement_resolver);
    RegistrySnapshotBuilder& add_core_tool_dispatch(
        ExecutableManifest manifest,
        ExecutableRequirementResolver requirement_resolver);
    RegistrySnapshotBuilder& add_core_endpoint_node(
        ExecutableManifest manifest,
        ExecutableRequirementResolver requirement_resolver);
    RegistrySnapshotBuilder& add_reducer(ExecutableManifest manifest, graph::ReducerFn reducer);
    RegistrySnapshotBuilder& add_condition(ExecutableManifest                  manifest,
                                           graph::ConditionFn                  condition,
                                           std::optional<graph::ConditionSpec> spec);
    RegistrySnapshotBuilder& add_provider(ExecutableManifest manifest, ProviderMetadata metadata);
    RegistrySnapshotBuilder& add_tool(ExecutableManifest manifest, ToolMetadata metadata);
    RegistrySnapshotBuilder& add_imported(ExecutableManifest         manifest,
                                          ImportedExecutableMetadata metadata);
    RegistrySnapshotBuilder& add_native(ExecutableManifest manifest, NativeControlBinding binding) &;
    RegistrySnapshotBuilder&& add_native(ExecutableManifest manifest, NativeControlBinding binding) &&;
    RegistrySnapshotBuilder&  add_native(std::uint32_t        import_slot,
                                         ExecutableManifest   manifest,
                                         NativeControlBinding binding) &;
    RegistrySnapshotBuilder&& add_native(std::uint32_t        import_slot,
                                         ExecutableManifest   manifest,
                                         NativeControlBinding binding) &&;
 
    RegistrySnapshot build() &&;
 
private:
    RegistrySnapshotBuilder& add_node_impl(
        ExecutableManifest            manifest,
        graph::NodeFactoryFn          factory,
        json                          config_schema,
        json                          effects,
        ExecutableRequirementResolver requirement_resolver,
        bool                          allow_executable_bindings);
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace neograph::program