identity_manager.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/core/identity_manager.h>
#include <entropic/types/logging.h>
 
#include <algorithm>
#include <filesystem>
#include <regex>
 
namespace entropic {
 
static auto logger = log::get("identity_manager");
 
static const std::vector<std::string> s_reserved_names = {
    "default", "none", "all", "router"};
 
static const std::regex s_name_regex("^[a-z][a-z0-9_-]{0,63}$");
 
// ── Phase validation (extracted for return count) ────────
 
static std::string validate_phases(
    const std::unordered_map<std::string,
                             PhaseConfig>& phases) {
    for (const auto& [phase_name, phase] : phases) {
        if (phase_name.empty()) {
            return "Phase name cannot be empty";
        }
        if (phase.max_output_tokens <= 0) {
            return "Phase '" + phase_name
                   + "' max_output_tokens must be > 0";
        }
    }
    return "";
}
 
// ── Field validation ─────────────────────────────────────
 
static std::string validate_fields(const IdentityConfig& config) {
    auto phase_err = validate_phases(config.phases);
    if (!phase_err.empty()) { return phase_err; }
    bool bad_adapter = !config.adapter_path.empty()
        && !std::filesystem::exists(config.adapter_path);
    return bad_adapter
        ? "Adapter path not found: " + config.adapter_path : "";
}
 
// ── Create precondition check (extracted for return count) ──
 
static entropic_error_t check_create_preconditions(
    const IdentityConfig& config,
    const IdentityManagerConfig& mgr_config,
    const std::unordered_map<std::string, IdentityConfig>& identities) {
    if (!mgr_config.allow_dynamic) {
        logger->warn("Dynamic identity creation disabled");
        return ENTROPIC_ERROR_INVALID_CONFIG;
    }
    if (identities.size() >= mgr_config.max_identities) {
        logger->warn("Identity limit reached: {}",
                     mgr_config.max_identities);
        return ENTROPIC_ERROR_LIMIT_REACHED;
    }
    bool exists = identities.count(config.name) > 0;
    if (exists) {
        logger->warn("Identity already exists: {}", config.name);
    }
    return exists ? ENTROPIC_ERROR_ALREADY_EXISTS : ENTROPIC_OK;
}
 
// ── Mutation precondition check (update/destroy) ─────────
 
static entropic_error_t check_mutable(
    const std::string& name,
    const std::unordered_map<std::string, IdentityConfig>& identities,
    std::unordered_map<std::string,
                       IdentityConfig>::const_iterator& out_it) {
    out_it = identities.find(name);
    if (out_it == identities.end()) {
        return ENTROPIC_ERROR_IDENTITY_NOT_FOUND;
    }
    return (out_it->second.origin == IdentityOrigin::STATIC)
        ? ENTROPIC_ERROR_PERMISSION_DENIED : ENTROPIC_OK;
}
 
// ── Constructor ──────────────────────────────────────────
 
IdentityManager::IdentityManager(const IdentityManagerConfig& config)
    : config_(config) {}
 
// ── Interface setters ────────────────────────────────────
 
void IdentityManager::set_grammar_interface(
    const GrammarValidationInterface& iface) {
    grammar_iface_ = iface;
}
 
void IdentityManager::set_mcp_interface(const MCPKeyInterface& iface) {
    mcp_iface_ = iface;
}
 
// ── load_static ──────────────────────────────────────────
 
size_t IdentityManager::load_static(
    const std::vector<IdentityConfig>& identities) {
    std::unique_lock lock(identities_mutex_);
    size_t loaded = 0;
    for (const auto& id : identities) {
        IdentityConfig cfg = id;
        cfg.origin = IdentityOrigin::STATIC;
        identities_[cfg.name] = std::move(cfg);
        ++loaded;
    }
    logger->info("Loaded {} static identities", loaded);
    router_dirty_.store(true, std::memory_order_release);
    fire_cache_invalidator();  // P1-7: identity change → drop prompt caches
    return loaded;
}
 
// ── create ───────────────────────────────────────────────
 
entropic_error_t IdentityManager::create(const IdentityConfig& config) {
    std::unique_lock lock(identities_mutex_);
    auto pre = check_create_preconditions(
        config, config_, identities_);
    if (pre != ENTROPIC_OK) { return pre; }
    auto err = validate(config, false);
    if (!err.empty()) {
        logger->warn("Identity validation failed: {}", err);
        return ENTROPIC_ERROR_INVALID_CONFIG;
    }
    IdentityConfig cfg = config;
    cfg.origin = IdentityOrigin::DYNAMIC;
    register_mcp_keys(cfg);
    identities_[cfg.name] = std::move(cfg);
    router_dirty_.store(true, std::memory_order_release);
    fire_cache_invalidator();  // P1-7: identity change → drop prompt caches
    logger->info("Identity created: name='{}', routable={}, "
                 "prompt={} chars",
                 config.name, config.routable,
                 config.system_prompt.size());
    return ENTROPIC_OK;
}
 
// ── update ───────────────────────────────────────────────
 
entropic_error_t IdentityManager::update(
    const std::string& name,
    const IdentityConfig& config) {
    std::unique_lock lock(identities_mutex_);
    std::unordered_map<std::string,
        IdentityConfig>::const_iterator it;
    auto pre = check_mutable(name, identities_, it);
    if (pre != ENTROPIC_OK) { return pre; }
    auto err = validate(config, true);
    if (!err.empty()) {
        logger->warn("Identity update validation failed: {}", err);
        return ENTROPIC_ERROR_INVALID_CONFIG;
    }
    unregister_mcp_keys(name);
    IdentityConfig cfg = config;
    cfg.origin = IdentityOrigin::DYNAMIC;
    cfg.name = name;
    register_mcp_keys(cfg);
    identities_[name] = std::move(cfg);
    router_dirty_.store(true, std::memory_order_release);
    fire_cache_invalidator();  // P1-7: identity change → drop prompt caches
    logger->info("Dynamic identity updated: {}", name);
    return ENTROPIC_OK;
}
 
// ── destroy ──────────────────────────────────────────────
 
entropic_error_t IdentityManager::destroy(const std::string& name) {
    std::unique_lock lock(identities_mutex_);
    std::unordered_map<std::string,
        IdentityConfig>::const_iterator it;
    auto pre = check_mutable(name, identities_, it);
    if (pre != ENTROPIC_OK) { return pre; }
    if (in_use_checker_ && in_use_checker_(name, in_use_user_data_)) {
        return ENTROPIC_ERROR_IN_USE;
    }
    unregister_mcp_keys(name);
    identities_.erase(it);
    router_dirty_.store(true, std::memory_order_release);
    fire_cache_invalidator();  // P1-7: identity change → drop prompt caches
    logger->info("Dynamic identity destroyed: {}", name);
    return ENTROPIC_OK;
}
 
// ── get ──────────────────────────────────────────────────
 
const IdentityConfig* IdentityManager::get(
    const std::string& name) const {
    std::shared_lock lock(identities_mutex_);
    auto it = identities_.find(name);
    return (it != identities_.end()) ? &it->second : nullptr;
}
 
// ── has ──────────────────────────────────────────────────
 
bool IdentityManager::has(const std::string& name) const {
    std::shared_lock lock(identities_mutex_);
    return identities_.count(name) > 0;
}
 
// ── list ─────────────────────────────────────────────────
 
std::vector<std::string> IdentityManager::list() const {
    std::shared_lock lock(identities_mutex_);
    std::vector<std::string> names;
    names.reserve(identities_.size());
    for (const auto& [k, _] : identities_) {
        names.push_back(k);
    }
    return names;
}
 
// ── list_routable ────────────────────────────────────────
 
std::vector<const IdentityConfig*>
IdentityManager::list_routable() const {
    std::shared_lock lock(identities_mutex_);
    std::vector<const IdentityConfig*> result;
    for (const auto& [_, cfg] : identities_) {
        if (cfg.routable && !cfg.interstitial) {
            result.push_back(&cfg);
        }
    }
    return result;
}
 
// ── count / count_dynamic ────────────────────────────────
 
size_t IdentityManager::count() const {
    std::shared_lock lock(identities_mutex_);
    return identities_.size();
}
 
size_t IdentityManager::count_dynamic() const {
    std::shared_lock lock(identities_mutex_);
    size_t n = 0;
    for (const auto& [_, cfg] : identities_) {
        if (cfg.origin == IdentityOrigin::DYNAMIC) {
            ++n;
        }
    }
    return n;
}
 
// ── Router dirty flag ────────────────────────────────────
 
bool IdentityManager::is_router_dirty() const {
    return router_dirty_.load(std::memory_order_acquire);
}
 
void IdentityManager::clear_router_dirty() {
    router_dirty_.store(false, std::memory_order_release);
}
 
// ── In-use checker ───────────────────────────────────────
 
void IdentityManager::set_in_use_checker(
    bool (*checker)(const std::string& name, void* user_data),
    void* user_data) {
    in_use_checker_ = checker;
    in_use_user_data_ = user_data;
}
 
void IdentityManager::set_cache_invalidator(void (*cb)(void*),
                                            void* user_data) {
    cache_invalidator_ = cb;
    cache_invalidator_data_ = user_data;
}
 
void IdentityManager::fire_cache_invalidator() {
    if (cache_invalidator_ != nullptr) {
        cache_invalidator_(cache_invalidator_data_);
    }
}
 
// ── validate ─────────────────────────────────────────────
 
std::string IdentityManager::validate_name(const std::string& name) {
    if (name.empty()) {
        return "Identity name cannot be empty";
    }
    if (!std::regex_match(name, s_name_regex)) {
        return "Identity name must match ^[a-z][a-z0-9_-]{0,63}$";
    }
    bool reserved = std::find(
        s_reserved_names.begin(), s_reserved_names.end(), name)
        != s_reserved_names.end();
    return reserved
        ? "Identity name '" + name + "' is reserved" : "";
}
 
std::string IdentityManager::validate(
    const IdentityConfig& config, bool is_update) const {
    if (!is_update) {
        auto name_err = validate_name(config.name);
        if (!name_err.empty()) { return name_err; }
    }
    if (config.focus.empty()) {
        return "Identity must have at least one focus keyword";
    }
    bool grammar_missing = !config.grammar_id.empty()
        && grammar_iface_.has_grammar
        && !grammar_iface_.has_grammar(
               config.grammar_id, grammar_iface_.user_data);
    return grammar_missing
        ? "Grammar '" + config.grammar_id + "' not found in registry"
        : validate_fields(config);
}
 
// ── MCP key registration ─────────────────────────────────
 
void IdentityManager::register_mcp_keys(const IdentityConfig& config) {
    if (config.mcp_keys.empty()) { return; }
    if (!mcp_iface_.register_identity) { return; }
    mcp_iface_.register_identity(config.name, mcp_iface_.user_data);
    for (const auto& key : config.mcp_keys) {
        if (mcp_iface_.grant) {
            mcp_iface_.grant(config.name, key.tool_pattern,
                             static_cast<int>(key.level),
                             mcp_iface_.user_data);
        }
    }
}
 
void IdentityManager::unregister_mcp_keys(const std::string& name) {
    if (!mcp_iface_.is_enforced || !mcp_iface_.unregister_identity) {
        return;
    }
    if (mcp_iface_.is_enforced(name, mcp_iface_.user_data)) {
        mcp_iface_.unregister_identity(name, mcp_iface_.user_data);
    }
}
 
} // namespace entropic