LLM_agent.h

Go to the documentation of this file.

 
 
#pragma once
 
#include "LLM.h"
#include "LLM_client.h"
 
struct UNDREAMAI_API ChatMessage
{
    std::string role;    
    std::string content; 
 
    ChatMessage() = default;
 
    ChatMessage(const std::string &role_, const std::string &content_)
        : role(role_), content(content_) {}
 
    json to_json() const
    {
        return json{{"role", role}, {"content", content.empty() ? " " : content}};
    }
 
    static ChatMessage from_json(const json &j)
    {
        return ChatMessage(j.at("role").get<std::string>(), j.at("content").get<std::string>());
    }
 
    bool operator==(const ChatMessage &other) const
    {
        return role == other.role && content == other.content;
    }
};
 
enum class ContextOverflowStrategy
{
    None,       
    Truncate,   
    Summarize   
};
 
const std::string SUMMARY_PROMPT=
"You are maintaining a concise working memory of an ongoing conversation."
""
"If an existing summary is provided, merge it with the new messages into a single updated summary."
"If no existing summary is provided, create a new summary from the messages."
""
"Rules:"
"- Preserve user goals, decisions made, constraints, preferences, open questions, and pending tasks."
"- Remove anything resolved, superseded, redundant, or purely conversational."
"- Keep only information relevant for future reasoning."
"- Avoid duplicating or rephrasing information unnecessarily."
"- Write in present tense where possible."
"- Keep under 200 words."
"- No bullet points. No preamble. Output only the summary text.";
 
class UNDREAMAI_API LLMAgent : public LLMLocal
{
public:
    const std::string USER_ROLE = "user";
    const std::string ASSISTANT_ROLE = "assistant";
 
    LLMAgent(LLMLocal *llm, const std::string &system_prompt = "");
 
    //=================================== LLM METHOD DELEGATES ===================================//
    std::string tokenize_json(const json &data) override { return llm->tokenize_json(data); }
 
    std::string detokenize_json(const json &data) override { return llm->detokenize_json(data); }
 
    std::string embeddings_json(const json &data) override { return llm->embeddings_json(data); }
 
    std::string completion_json(const json &data, CharArrayFn callback = nullptr, bool callbackWithJSON = true) override { return llm->completion_json(data, callback, callbackWithJSON); }
 
    std::string apply_template_json(const json &data) override { return llm->apply_template_json(data); }
 
    std::string slot_json(const json &data) override { return llm->slot_json(data); }
 
    void cancel(int id_slot) override { return llm->cancel(id_slot); }
 
    int get_next_available_slot() override { return llm->get_next_available_slot(); }
 
    int get_slot_context_size() override { return llm->get_slot_context_size(); }
 
    //=================================== LLM METHOD DELEGATES ===================================//
 
    //=================================== Slot-aware method overrides ===================================//
    virtual json build_completion_json(const std::string &prompt) { return LLMLocal::build_completion_json(prompt, this->id_slot); }
 
    virtual std::string completion(const std::string &prompt, CharArrayFn callback = nullptr, bool return_response_json = false)
    {
        return LLMLocal::completion(prompt, callback, this->id_slot, return_response_json);
    }
 
    virtual json build_slot_json(const std::string &action, const std::string &filepath) { return LLMLocal::build_slot_json(this->id_slot, action, filepath); }
 
    virtual std::string save_slot(const std::string &filepath) { return LLMLocal::save_slot(this->id_slot, filepath); }
 
    virtual std::string load_slot(const std::string &filepath) { return LLMLocal::load_slot(this->id_slot, filepath); }
 
    virtual void cancel() { llm->cancel(this->id_slot); }
    //=================================== Slot-aware method overrides ===================================//
 
    inline int get_slot() { return id_slot; }
 
    void set_slot(int id_slot);
 
    // Prompt configuration methods
 
    void set_system_prompt(const std::string &system_prompt_) { system_prompt = system_prompt_; }
 
    std::string get_system_prompt() const { return system_prompt; }
 
    void set_history(const json &history_) { history = history_; }
 
    json get_history() const { return history; }
 
    // History management methods
 
    void add_user_message(const std::string &content) { add_message(USER_ROLE, content); }
 
    void add_assistant_message(const std::string &content) { add_message(ASSISTANT_ROLE, content); }
 
    void clear_history();
 
    void remove_last_message();
 
    void save_history(const std::string &filepath) const;
 
    void load_history(const std::string &filepath);
 
    size_t get_history_size() const { return history.size(); }
 
    // Context overflow management
 
    void set_overflow_strategy(
        ContextOverflowStrategy strategy,
        float target_ratio = 0.5f,
        const std::string &summarize_prompt = SUMMARY_PROMPT
    )
    {
        overflow_strategy = strategy;
        target_context_ratio = target_ratio;
        this->summarize_prompt = summarize_prompt;
    }
 
    ContextOverflowStrategy get_overflow_strategy() const { return overflow_strategy; }
 
    std::string get_summarize_prompt() const { return summarize_prompt; }
 
    std::string get_summary() const { return summary; }
 
    void set_summary(const std::string &summary_) { summary = summary_; }
 
    // Chat functionality
 
    std::string chat(const std::string &user_prompt, bool add_to_history = true, CharArrayFn callback = nullptr, bool return_response_json = false, bool debug_prompt = false);
 
protected:
    void set_n_keep();
 
    json build_system_history() const;
 
    json build_working_history(const std::string &user_prompt, bool include_history=true) const;
 
    bool handle_overflow(const std::string &user_prompt);
 
    void truncate_history(const std::string &user_prompt);
 
    void summarize_history(const std::string &user_prompt);
 
    virtual void add_message(const std::string &role, const std::string &content);
 
private:
    LLMLocal *llm = nullptr;                  
    int id_slot = -1;                         
    std::string system_prompt = "";           
    std::string system_role = "system";       
    std::string summary = "";                 
    json history;                             
 
    // Context overflow
    ContextOverflowStrategy overflow_strategy = ContextOverflowStrategy::Truncate;
    float target_context_ratio = 0.5f;        
    std::string summarize_prompt = SUMMARY_PROMPT;
};
 
 
extern "C"
{
    UNDREAMAI_API LLMAgent *LLMAgent_Construct(LLMLocal *llm, const char *system_prompt = "");
 
    UNDREAMAI_API void LLMAgent_Set_System_Prompt(LLMAgent *llm, const char *system_prompt);
 
    UNDREAMAI_API const char *LLMAgent_Get_System_Prompt(LLMAgent *llm);
 
    UNDREAMAI_API void LLMAgent_Set_Slot(LLMAgent *llm, int slot_id);
 
    UNDREAMAI_API int LLMAgent_Get_Slot(LLMAgent *llm);
 
    UNDREAMAI_API const char *LLMAgent_Chat(LLMAgent *llm, const char *user_prompt, bool add_to_history = true, CharArrayFn callback = nullptr, bool return_response_json = false, bool debug_prompt = false);
 
    UNDREAMAI_API void LLMAgent_Clear_History(LLMAgent *llm);
 
    UNDREAMAI_API const char *LLMAgent_Get_History(LLMAgent *llm);
 
    UNDREAMAI_API void LLMAgent_Set_History(LLMAgent *llm, const char *history_json);
 
    UNDREAMAI_API void LLMAgent_Add_User_Message(LLMAgent *llm, const char *content);
 
    UNDREAMAI_API void LLMAgent_Add_Assistant_Message(LLMAgent *llm, const char *content);
 
    UNDREAMAI_API void LLMAgent_Remove_Last_Message(LLMAgent *llm);
 
    UNDREAMAI_API void LLMAgent_Save_History(LLMAgent *llm, const char *filepath);
 
    UNDREAMAI_API void LLMAgent_Load_History(LLMAgent *llm, const char *filepath);
 
    UNDREAMAI_API size_t LLMAgent_Get_History_Size(LLMAgent *llm);
 
    UNDREAMAI_API void LLMAgent_Set_Overflow_Strategy(LLMAgent *llm, int strategy, float target_ratio, const char *summarize_prompt);
 
    UNDREAMAI_API const char *LLMAgent_Get_Summary(LLMAgent *llm);
 
    UNDREAMAI_API void LLMAgent_Set_Summary(LLMAgent *llm, const char *summary);
}