task_graph_proposal.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/program/source.h>
 
#include <cstdint>
#include <memory>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph::program {
 
struct TaskGraphBudget {
    std::uint64_t wall_time_ms         = 0;
    std::uint64_t model_tokens         = 0;
    std::uint64_t monetary_microunits  = 0;
    std::uint64_t output_bytes         = 0;
 
    bool operator==(const TaskGraphBudget&) const = default;
};
 
struct TaskGraphArtifactContract {
    std::string              artifact;
    std::vector<std::string> fields;
 
    bool operator==(const TaskGraphArtifactContract&) const = default;
};
 
struct TaskGraphTemplateContract {
    std::string                            template_id;
    std::string                            content_identity;
    std::vector<std::string>               input_fields;
    std::vector<TaskGraphArtifactContract> output_artifacts;
    TaskGraphBudget                        budget_ceiling;
    std::string                            child_binding;
    std::string                            executable_identity;
    std::string                            kind;
    std::vector<std::string>               capabilities;
    std::vector<std::string>               effects;
 
    bool operator==(const TaskGraphTemplateContract&) const = default;
};
 
struct TaskGraphProposalLimits {
    std::uint64_t    max_tasks = 0;
    std::uint64_t    max_edges = 0;
    std::uint64_t    max_depth = 0;
    TaskGraphBudget  per_task_budget_ceiling;
    TaskGraphBudget  total_budget_ceiling;
    std::uint32_t    min_schema_version = 1;
    std::uint32_t    max_attempts = 1;
    std::uint32_t    max_literal_bytes = 0;
    std::uint32_t    max_total_literal_bytes = 0;
 
    bool operator==(const TaskGraphProposalLimits&) const = default;
};
 
struct TaskGraphProposalOptions {
    std::string                            source_id;
    std::vector<SourceMapEntry>            source_map;
    TaskGraphProposalLimits                limits;
    std::vector<TaskGraphTemplateContract> template_allowlist;
};
 
struct TaskGraphArtifactReference {
    std::string task_id;
    std::string artifact;
    std::string field;
 
    bool operator==(const TaskGraphArtifactReference&) const = default;
};
 
struct TaskGraphInputTarget {
    std::string field;
 
    bool operator==(const TaskGraphInputTarget&) const = default;
};
 
struct TaskGraphInputBinding {
    TaskGraphArtifactReference from;
    TaskGraphInputTarget       to;
 
    bool operator==(const TaskGraphInputBinding&) const = default;
};
 
struct TaskGraphInputLiteral {
    TaskGraphInputTarget to;
    json                 value;
 
    bool operator==(const TaskGraphInputLiteral&) const = default;
};
 
struct TaskGraphTask {
    std::string                        id;
    std::string                        template_id;
    std::vector<TaskGraphInputBinding> input_bindings;
    std::vector<std::string>           depends_on;
    TaskGraphBudget                    budget;
    std::vector<TaskGraphInputLiteral> literals;
    std::uint32_t                      max_attempts = 1;
 
    bool operator==(const TaskGraphTask&) const = default;
};
 
enum class TaskGraphJoinKind : std::uint8_t { All };
 
NEOGRAPH_PROGRAM_API std::string_view to_string(TaskGraphJoinKind kind) noexcept;
NEOGRAPH_PROGRAM_API TaskGraphJoinKind task_graph_join_kind_from_string(std::string_view value);
 
struct TaskGraphJoinPolicy {
    TaskGraphJoinKind kind = TaskGraphJoinKind::All;
 
    bool operator==(const TaskGraphJoinPolicy&) const = default;
};
 
class NEOGRAPH_PROGRAM_API TaskGraphProposalError final : public std::runtime_error {
public:
    explicit TaskGraphProposalError(std::vector<Diagnostic> diagnostics);
    const std::vector<Diagnostic>& diagnostics() const noexcept;
 
private:
    std::vector<Diagnostic> diagnostics_;
};
 
class NEOGRAPH_PROGRAM_API TaskGraphProposal final {
public:
    static constexpr std::uint32_t SCHEMA_VERSION   = 1;
    static constexpr std::uint32_t SCHEMA_VERSION_2 = 2;
 
    TaskGraphProposal(const TaskGraphProposal&)            = default;
    TaskGraphProposal& operator=(const TaskGraphProposal&) = default;
    TaskGraphProposal(TaskGraphProposal&&) noexcept        = default;
    TaskGraphProposal& operator=(TaskGraphProposal&&) noexcept = default;
    ~TaskGraphProposal();
 
    static TaskGraphProposal parse(const json& proposal, TaskGraphProposalOptions options);
 
    std::uint32_t                           schema_version() const noexcept;
    const std::string&                      source_id() const noexcept;
    const std::vector<SourceMapEntry>&      source_map() const noexcept;
    const std::vector<TaskGraphTask>&       tasks() const noexcept;
    const TaskGraphJoinPolicy&              join() const noexcept;
    const std::string&                      id() const noexcept;
    const std::string&                      proposal_hash() const noexcept;
    json                                    to_json() const;
    const std::string&                      serialize_canonical() const noexcept;
 
private:
    struct Impl;
    explicit TaskGraphProposal(std::shared_ptr<const Impl> impl);
    std::shared_ptr<const Impl> impl_;
};
 
}  // namespace neograph::program