manager.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/entropic_export.h>
#include <entropic/types/config.h>
 
#include <filesystem>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace entropic::prompts {
 
using PhaseConfig = entropic::PhaseConfig;
 
enum class PromptType {
    CONSTITUTION,  
    APP_CONTEXT,   
    IDENTITY,      
};
 
struct BenchmarkPrompt {
    std::string prompt;                      
    std::vector<std::string> checks_yaml;    
};
 
struct BenchmarkSpec {
    std::vector<BenchmarkPrompt> prompts; 
};
 
struct IdentityFrontmatter {
    PromptType type = PromptType::IDENTITY;    
    int version = 1;                           
 
    std::string name;                          
    std::vector<std::string> focus;            
    std::vector<std::string> examples;         
    std::optional<std::string> grammar;        
    std::optional<std::string> auto_chain;     
    std::optional<std::vector<std::string>> allowed_tools; 
    std::optional<std::vector<std::string>> bash_commands;  
    std::optional<int> max_output_tokens;      
    std::optional<float> temperature;          
    std::optional<float> top_p;                
    std::optional<int> top_k;                  
    std::optional<float> min_p;                
    std::optional<float> presence_penalty;     
    std::optional<float> frequency_penalty;    
    std::optional<float> repeat_penalty;       
    std::optional<bool> enable_thinking;       
    bool interstitial = false;                 
    bool routable = true;                      
    bool explicit_completion = false;          
    std::vector<std::string> validation_rules; 
    bool relay_single_delegate = false;        
    int max_iterations = -1;                   
    int max_tool_calls_per_turn = -1;          
    std::optional<std::unordered_map<std::string, PhaseConfig>> phases; 
    std::optional<BenchmarkSpec> benchmark;    
};
 
struct ParsedPrompt {
    PromptType type;       
    int version = 1;       
    std::string body;      
};
 
struct ParsedIdentity {
    IdentityFrontmatter frontmatter; 
    std::string body;                
};
 
ENTROPIC_EXPORT const char* prompt_type_to_string(PromptType type);
 
ENTROPIC_EXPORT std::string parse_prompt_file(
    const std::filesystem::path& path,
    PromptType expected_type,
    ParsedPrompt& result);
 
ENTROPIC_EXPORT std::string load_identity(
    const std::filesystem::path& path,
    ParsedIdentity& identity);
 
ENTROPIC_EXPORT std::string load_constitution(
    const std::optional<std::filesystem::path>& constitution_path,
    bool disabled,
    const std::filesystem::path& data_dir,
    std::string& body);
 
ENTROPIC_EXPORT std::string load_app_context(
    const std::optional<std::filesystem::path>& app_context_path,
    bool disabled,
    const std::filesystem::path& data_dir,
    std::string& body);
 
ENTROPIC_EXPORT std::string resolve_tier_identity(
    const entropic::TierConfig& tier_config,
    const std::string& tier_name,
    const std::filesystem::path& data_dir);
 
ENTROPIC_EXPORT ParsedIdentity resolve_tier_identity_full(
    const entropic::TierConfig& tier_config,
    const std::string& tier_name,
    const std::filesystem::path& data_dir);
 
ENTROPIC_EXPORT std::string assemble(
    const entropic::ParsedConfig& config,
    const std::filesystem::path& data_dir);
 
} // namespace entropic::prompts