step_plan.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/program/source.h>
#include <neograph/program/task_graph_proposal.h>
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
namespace neograph::program {
 
struct StepPlanViolation {
    std::string path;
    std::string code;
    std::string message;
    std::string hint;
    json detail = json::object();
 
    bool operator==(const StepPlanViolation&) const = default;
};
 
struct StepPlanLimits {
    std::uint32_t max_steps               = 32;
    std::uint32_t max_params_per_step     = 16;
    std::uint32_t max_after_per_step      = 8;
    std::uint32_t max_literal_bytes       = 4096;
    std::uint32_t max_total_literal_bytes = 32768;
    std::uint32_t max_literal_depth       = 6;
    std::uint32_t max_retry_attempts      = 3;
    std::uint32_t max_violations          = 32;
    std::uint32_t max_document_bytes      = 131072;
};
 
struct StepPlanTemplateInfo {
    std::string              template_id;
    std::vector<std::string> required_params;
    std::string              summary;
 
    bool operator==(const StepPlanTemplateInfo&) const = default;
};
 
struct StepPlanIntakeOptions {
    std::string                            source_id = "step-plan";
    StepPlanLimits                         limits;
    TaskGraphProposalLimits                proposal_limits;
    std::vector<TaskGraphTemplateContract> template_allowlist;
    std::vector<StepPlanTemplateInfo>      template_info;
};
 
enum class StepPlanEnvelope : std::uint8_t {
    None,
    Strict,
    Recovered,
};
 
NEOGRAPH_PROGRAM_API std::string_view to_string(StepPlanEnvelope envelope) noexcept;
 
struct StepPlanIntakeResult {
    std::vector<StepPlanViolation> violations;
    StepPlanEnvelope               envelope = StepPlanEnvelope::None;
    std::string                    plan_digest;
    std::optional<json>            proposal;
    std::optional<std::string>     proposal_hash;
    std::vector<SourceMapEntry>    source_map;
    json                           report = json::object();
 
    bool ok() const noexcept { return violations.empty() && proposal.has_value(); }
};
 
NEOGRAPH_PROGRAM_API StepPlanIntakeResult
intake_step_plan_text(std::string_view text, const StepPlanIntakeOptions& options);
 
NEOGRAPH_PROGRAM_API StepPlanIntakeResult
intake_step_plan_document(const json& document, const StepPlanIntakeOptions& options);
 
inline StepPlanIntakeResult intake_step_plan(std::string_view            text,
                                             const StepPlanIntakeOptions& options) {
    return intake_step_plan_text(text, options);
}
 
template <class Document,
          std::enable_if_t<std::is_same_v<std::remove_cv_t<std::remove_reference_t<Document>>, json>,
                           int> = 0>
StepPlanIntakeResult intake_step_plan(const Document& document,
                                      const StepPlanIntakeOptions& options) {
    return intake_step_plan_document(document, options);
}
 
NEOGRAPH_PROGRAM_API std::string
format_violations_for_model(const std::vector<StepPlanViolation>& violations,
                            std::size_t                           max_bytes);
 
NEOGRAPH_PROGRAM_API json
step_plan_json_schema(const std::vector<TaskGraphTemplateContract>& templates,
                      const StepPlanLimits&                         limits);
 
}  // namespace neograph::program