input.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 ForestHub. All rights reserved.
// For commercial licensing, visit https://github.com/ForestHubAI/fh-sdk
 
#ifndef FORESTHUB_CORE_INPUT_HPP
#define FORESTHUB_CORE_INPUT_HPP

 
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "foresthub/util/json.hpp"
 
namespace foresthub {
namespace core {
 
using json = nlohmann::json;

enum class InputType : uint8_t {
    kString,  
    kItems    
};

class Input {
public:
    virtual ~Input() = default;

    virtual InputType GetInputType() const = 0;

    virtual void ToJson(json& j) const = 0;
};

enum class InputItemType : uint8_t {
    kString,     
    kToolCall,   
    kToolResult  
};

class InputItem {
public:
    virtual ~InputItem() = default;

    virtual InputItemType GetItemType() const = 0;

    virtual std::string ToString() const = 0;

    virtual void ToJson(json& j) const = 0;
};

class InputString : public Input, public InputItem {
public:
    std::string text;  

    explicit InputString(std::string text) : text(std::move(text)) {}

    std::string ToString() const override { return text; }
    InputItemType GetItemType() const override { return InputItemType::kString; }
    InputType GetInputType() const override { return InputType::kString; }
    void ToJson(json& j) const override { j = json{{"value", text}}; }
};

class InputItems : public Input {
public:
    std::vector<std::shared_ptr<InputItem>> items;  

    InputItems() = default;

    explicit InputItems(const std::shared_ptr<InputItem>& item) { items.push_back(item); }

    void PushBack(const std::shared_ptr<InputItem>& item) { items.push_back(item); }

    InputType GetInputType() const override { return InputType::kItems; }

    void ToJson(json& j) const override {
        j = json::array();
        for (const auto& item : items) {
            json item_j;
            if (item) {
                item->ToJson(item_j);
            } else {
                item_j = nullptr;
            }
            j.push_back(std::move(item_j));
        }
    }

    using Iterator = std::vector<std::shared_ptr<InputItem>>::iterator;
    using ConstIterator = std::vector<std::shared_ptr<InputItem>>::const_iterator;

    Iterator Begin() { return items.begin(); }
    Iterator End() { return items.end(); }
    ConstIterator Begin() const { return items.begin(); }
    ConstIterator End() const { return items.end(); }

    template <typename... Args>
    void Insert(Args&&... args) {
        items.insert(std::forward<Args>(args)...);
    }
};

inline std::shared_ptr<InputItems> AsInputItems(const std::shared_ptr<Input>& input) {
    if (!input) {
        return std::make_shared<InputItems>();
    }
 
    switch (input->GetInputType()) {
        case InputType::kItems:
            return std::static_pointer_cast<InputItems>(input);
        case InputType::kString: {
            auto new_list = std::make_shared<InputItems>();
            new_list->PushBack(std::static_pointer_cast<InputString>(input));
            return new_list;
        }
    }
 
    return std::make_shared<InputItems>();
}
 
}  // namespace core
}  // namespace foresthub
 
#endif  // FORESTHUB_CORE_INPUT_HPP