config.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/types/enums.h>
 
#include <cstdint>
#include <string>
#include <vector>
#include <optional>
#include <filesystem>
#include <unordered_map>
 
namespace entropic {
 
enum class MCPAccessLevel : uint8_t {
    NONE  = 0,  
    READ  = 1,  
    WRITE = 2,  
};
 
struct MCPKey {
    std::string tool_pattern;  
    MCPAccessLevel level;      
};
 
const char* mcp_access_level_name(MCPAccessLevel level);
 
bool parse_mcp_access_level(const std::string& name, MCPAccessLevel& out);
 
struct GrammarEntry {
    std::string key;            
    std::string gbnf_content;   
    std::string source;         
    bool validated = false;     
    std::string error;          
};
 
enum class ModelState : int {
    COLD   = ENTROPIC_MODEL_STATE_COLD,    
    WARM   = ENTROPIC_MODEL_STATE_WARM,    
    ACTIVE = ENTROPIC_MODEL_STATE_ACTIVE,  
};
 
enum class AdapterState : int {
    COLD = 0,  
    WARM = 1,  
    HOT  = 2   
};
 
struct AdapterInfo {
    std::string name;                    
    std::filesystem::path path;          
    AdapterState state = AdapterState::COLD;  
    float scale = 1.0f;                 
    std::string tier_name;              
    std::string base_model_path;        
    size_t ram_bytes = 0;               
 
    std::unordered_map<std::string, std::string> metadata;
};
 
struct ModelConfig {
    std::filesystem::path path;              
    std::string adapter = "qwen35";          
    int context_length = 16384;              
    int gpu_layers = -1;                     
 
    bool gpu_layers_auto = false;
 
    bool keep_warm = false;
 
    bool use_mlock = true;                   
 
    int cpu_moe_layers = 0;
 
    /* ── llama.cpp pass-through ────────────────────────── */
    int reasoning_budget = -1;               
    std::string cache_type_k = "f16";        
    std::string cache_type_v = "f16";        
    int n_batch = 512;                       
 
    int n_ubatch = 0;
 
    int n_threads = 0;                       
    std::string tensor_split;                
 
    std::string split_mode;
 
    int main_gpu = 0;
 
    bool offload_kqv = true;
 
    float rope_freq_base = 0.0f;
 
    float rope_freq_scale = 0.0f;
 
    int n_parallel = 1;
 
    int max_sessions = 1;
 
    bool flash_attn = true;                  
 
    /* ── Tool filtering ────────────────────────────────── */
    std::optional<std::vector<std::string>> allowed_tools; 
 
    /* ── Vision / multimodal (v1.9.11) ────────────────── */
 
    std::filesystem::path mmproj_path;
 
    /* ── Model format (v1.9.13) ───────────────────────── */
 
    std::string model_format = "gguf";
};
 
struct PromptCacheConfig {
    size_t max_bytes = 536870912;  
    bool enabled = true;           
    bool log_hits = true;          
    bool warm_keep = true;
};
 
struct GPUResourceProfile {
    std::string name;              
    int n_batch = 512;             
    int n_threads = 0;             
    int n_threads_batch = 0;       
    std::string description;       
};
 
struct GenerationParams {
    std::string session_key;
 
    float temperature = 0.7f;                
    float top_p = 0.9f;                      
    int top_k = 40;                          
    float repeat_penalty = 1.1f;             
 
    float min_p = 0.0f;
 
    float presence_penalty = 0.0f;
 
    std::unordered_map<int32_t, float> logit_bias;
 
    float frequency_penalty = 0.0f;
 
    int max_tokens = 4096;                   
 
    int seed = -1;
    int reasoning_budget = -1;               
    bool enable_thinking = true;             
    std::string grammar;                     
    std::string grammar_key;
 
    std::string resolved_grammar_key;
 
    bool grammar_from_tier = false;
 
    std::vector<std::string> stop;           
    std::string tool_call_mode;
    int logprobs = 0;                        
 
    /* ── v1.9.7: Time cap + profile fields ────────────── */
 
    int time_limit_ms = 0;
 
    std::string profile;
 
    bool auto_adapt = true;
 
    float adapt_headroom = 0.9f;
 
    std::string tools;
};
 
struct TierConfig : ModelConfig {
    std::optional<std::filesystem::path> identity;  
    bool identity_disabled = false;                 
    std::optional<std::filesystem::path> grammar;   
    std::optional<std::string> auto_chain;           
    std::optional<bool> routable;                   
 
    bool requires_context = false;
 
    std::optional<std::filesystem::path> adapter_path;
 
    float adapter_scale = 1.0f;
 
    std::vector<std::string> capabilities;
 
    std::optional<float> temperature;
 
    std::optional<int> max_output_tokens;
 
    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;   
    std::optional<std::string> tool_call_mode;
 
    std::optional<bool> speculative_mtp;
 
    std::optional<bool> require_tool_call;
 
    bool has_capability(const std::string& name) const {
        for (const auto& c : capabilities) {
            if (c == name) { return true; }
        }
        return false;
    }
 
    std::string get_param(const std::string& param_name) const {
        if (param_name == "explicit_completion") {
            return auto_chain.has_value() ? "false" : "true";
        }
        return "";
    }
};
 
struct ModelsConfig {
    std::unordered_map<std::string, TierConfig> tiers; 
    std::optional<ModelConfig> router;                  
    std::string default_tier = "lead";                  
 
    bool defer_load = false;
 
    std::string find_tier_by_path(
        const std::filesystem::path& model_path) const {
        for (const auto& [name, tier] : tiers) {
            if (tier.path == model_path) { return name; }
        }
        return "";
    }
};
 
struct RoutingConfig {
    bool enabled = false;                                          
    std::string fallback_tier = "lead";                            
    std::optional<std::string> classification_prompt;               
    std::unordered_map<std::string, std::string> tier_map;          
    std::unordered_map<std::string, std::vector<std::string>> handoff_rules; 
};
 
struct PermissionsConfig {
    std::vector<std::string> allow;   
    std::vector<std::string> deny;    
    bool auto_approve = false;        
};
 
enum class OutsideRootAccess {
    refuse,    
    allow,     
    optional,  
};
 
struct FilesystemConfig {
    bool diagnostics_on_edit = true;   
    bool fail_on_errors = true;        
    float diagnostics_timeout = 1.0f;  
 
    OutsideRootAccess allow_outside_root = OutsideRootAccess::optional;
 
    std::vector<std::filesystem::path> outside_root_allow;
 
    std::vector<std::filesystem::path> outside_root_deny;
 
    std::optional<int> max_read_bytes;
    float max_read_context_pct = 0.25f; 
 
    int max_walk_entries = 250000;
};
 
struct ExternalMCPConfig {
    bool enabled = false;                                
    std::optional<std::filesystem::path> socket_path;    
    int rate_limit = 10;
    bool ask_streaming = true;
 
    int http_port = 0;
 
    std::string tool_prefix = "entropic";
 
    std::string server_name = "entropic";
 
    std::unordered_map<std::string, std::string> tool_descriptions;
};
 
struct BashConfig {
    int timeout_seconds = 30;  
};
 
struct ReconnectConfig {
    uint32_t base_delay_ms = 1000;   
    uint32_t max_delay_ms = 60000;   
    uint32_t max_retries = 5;        
    double backoff_factor = 2.0;     
};
 
struct ExternalServerEntry {
    std::string command;                             
    std::vector<std::string> args;                   
    std::unordered_map<std::string, std::string> env; 
    std::string url;                                 
};
 
struct MCPConfig {
    bool enable_entropic = true;     
    bool enable_filesystem = true;   
    bool enable_bash = true;         
    bool enable_git = true;          
    bool enable_diagnostics = false; 
    bool enable_web = false;         
    FilesystemConfig filesystem;     
    BashConfig bash;                 
    ExternalMCPConfig external;      
    int server_timeout_seconds = 10;
    std::string working_dir;         
 
    std::vector<std::filesystem::path> plugins;
 
    /* ── v1.8.7: External MCP client settings ──────────── */
    std::unordered_map<std::string, ExternalServerEntry> external_servers;
 
    /* ── v2.14.0: .mcp.json discovery, Claude-Code style ─── */
    std::vector<std::string> enabled_mcpjson_servers;
    std::vector<std::string> disabled_mcpjson_servers;
    bool enable_all_project_mcp_servers = false;
    ReconnectConfig reconnect;                   
    uint32_t health_check_interval_ms = 0;       
    uint32_t tool_call_timeout_ms = 30000;       
};
 
struct AuditLogConfig {
    std::filesystem::path log_dir;       
    std::string session_id;              
    bool enabled = true;                 
    size_t flush_interval_entries = 10;  
    size_t max_file_size = 0;            
    size_t max_files = 5;                
};
 
struct StorageConfig {
    bool enabled = true;                           
    std::filesystem::path db_path;                 
    size_t log_max_file_size = 10 * 1024 * 1024;   
    size_t log_max_files = 3;                       
    AuditLogConfig audit_log;                       
};
 
struct CompactionConfig {
    bool enabled = true;                       
    float threshold_percent = 0.75f;           
    int preserve_recent_turns = 2;             
    int summary_max_tokens = 1500;             
    bool notify_user = true;                   
    bool save_full_history = true;             
    int tool_result_ttl = 10;                  
    float warning_threshold_percent = 0.6f;    
};
 
enum class DelegationIsolation {
    none,     
    sandbox,  
};
 
struct DelegationConfig {
    DelegationIsolation isolation = DelegationIsolation::none; 
};
 
struct GenerationConfig {
    int max_tokens = 4096;            
    float default_temperature = 0.7f; 
    float default_top_p = 0.9f;       
 
    std::string budget_mode = "off";
 
    int budget_limit = 0;
 
    bool stream_output = true;
};
 
struct LSPServerConfig {
    std::string command;                
    std::vector<std::string> args;     
    std::vector<std::string> extensions; 
};
 
struct LSPConfig {
    bool enabled = true;          
    bool python_enabled = true;   
    bool c_enabled = true;        
    std::unordered_map<std::string, LSPServerConfig> servers; 
};
 
struct ConstitutionalValidationConfig {
    bool enabled = false;             
    int max_revisions = 2;            
    int max_critique_tokens = 1024;   
    float temperature = 0.0f;         
    bool enable_thinking = false;     
    int priority = 100;               
    std::string grammar_key = "constitutional_critique";  
    std::vector<std::string> skip_tiers = {"lead"};
    std::string critique_tier;
};
 
inline ModelConfig make_default_draft_model_config() {
    ModelConfig cfg;
    cfg.gpu_layers = 0;
    cfg.flash_attn = false;
    cfg.context_length = 8192;
    cfg.n_threads = 4;
    return cfg;
}
 
struct SpeculativeConfig {
    bool enabled = false;                  
    int n_draft = 4;                       
    bool mtp = false;                      
 
    ModelConfig draft = make_default_draft_model_config();
};
 
struct InferenceConfig {
    SpeculativeConfig speculative;         
};
 
struct ParsedConfig {
    ModelsConfig models;              
    RoutingConfig routing;            
    GenerationConfig generation;      
    PermissionsConfig permissions;    
    MCPConfig mcp;                    
    CompactionConfig compaction;      
    DelegationConfig delegation;      
    LSPConfig lsp;                    
    PromptCacheConfig prompt_cache;   
    StorageConfig storage;            
    std::string log_level = "INFO";   
 
    std::optional<std::filesystem::path> constitution;
    bool constitution_disabled = false; 
 
    std::optional<std::filesystem::path> app_context;
    bool app_context_disabled = false; 
    std::optional<std::string> app_context_content;
 
    std::filesystem::path workspace_app_context;
 
    bool concurrent_sessions = true;
 
    bool inject_model_context = true;  
    int vram_reserve_mb = 512;         
 
    std::filesystem::path config_dir;
 
    std::filesystem::path log_dir;
 
    bool ggml_logging = false;
 
    std::filesystem::path llama_log_path;
 
    bool console_logging = true;
 
    ConstitutionalValidationConfig constitutional_validation;
 
    InferenceConfig inference;
};
 
struct PhaseConfig {
    float temperature = 0.7f;            
    int max_output_tokens = 4096;        
    bool enable_thinking = false;        
    float repeat_penalty = 1.1f;         
    std::optional<std::vector<std::string>> bash_commands; 
};
 
} // namespace entropic