autonomous_agent.h

#pragma once
 
#include <agents-cpp/agent.h>
#include <agents-cpp/coroutine_utils.h>
#include <atomic>
#include <condition_variable>
#include <mutex>
#include <thread>
 
namespace agents {

class AutonomousAgent : public Agent {
public:
    struct Step {
        String description;
        String status;
        JsonObject result;
        bool success;
    };

    enum class PlanningStrategy {
        ZERO_SHOT,
        TREE_OF_THOUGHT,
        PLAN_AND_EXECUTE,
        REFLEXION,
        REACT
    };

    AutonomousAgent(std::shared_ptr<AgentContext> context);

    ~AutonomousAgent() override = default;

    void init() override;

    Task<JsonObject> run(const String& task) override;

    void stop() override;

    void provideFeedback(const String& feedback) override;

    void setSystemPrompt(const String& system_prompt);

    void setPlanningStrategy(PlanningStrategy strategy);

    std::vector<Step> getSteps() const;

    void setStepCallback(std::function<void(const Step&)> callback);

    Task<String> waitForFeedback(const String& message, const JsonObject& context) override;
 
private:
    String system_prompt_;
    PlanningStrategy planning_strategy_ = PlanningStrategy::REACT;
    std::vector<Step> steps_;
    std::function<void(const Step&)> step_callback_;
 
    // Execution state
    std::atomic<bool> should_stop_{false};

    std::promise<String> feedback_promise_;

    Task<JsonObject> executeTask(const String& task);

    Task<Step> executeStep(const String& step_description, const JsonObject& context);

    void recordStep(const Step& step);

    String getToolDescriptions() const;

    Task<JsonObject> planZeroShot(const String& task);

    Task<JsonObject> planTreeOfThought(const String& task);

    Task<JsonObject> planAndExecute(const String& task);

    Task<JsonObject> planReflexion(const String& task);

    Task<JsonObject> planReact(const String& task);

    std::vector<std::string> split_by_newline(const std::string& text) {
        std::vector<std::string> lines;
        std::istringstream iss(text);
        std::string line;
 
        // Read lines from the stringstream until the end, delimited by '\n'
        while (std::getline(iss, line, '\n')) {
            lines.push_back(line);
        }
        return lines;
    }
};
 
} // namespace agents