Tool Use Agent Pattern in C++

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <functional>
#include <memory>
#include <format>
#include <chrono>
#include <stdexcept>
#include <optional>

// [step] Define structured tool schema and result types
struct ToolParam {
    std::string name;
    std::string type;
    std::string description;
    bool required = true;
};

struct ToolDefinition {
    std::string name;
    std::string description;
    std::vector<ToolParam> params;
};

struct ToolCallResult {
    std::string callId;
    std::string toolName;
    std::string output;
    bool isError;
    std::chrono::milliseconds duration;
};

// [step] Build the ITool interface and typed registry with validation
class ITool {
public:
    virtual ~ITool() = default;
    virtual ToolDefinition definition() const = 0;
    virtual std::string execute(const std::map<std::string, std::string>& params) = 0;
};

class ToolRegistry {
    std::map<std::string, std::unique_ptr<ITool>> tools_;
    int nextCallId_ = 0;

public:
    void registerTool(std::unique_ptr<ITool> tool) {
        auto def = tool->definition();
        tools_.emplace(def.name, std::move(tool));
    }

    std::vector<ToolDefinition> definitions() const {
        std::vector<ToolDefinition> defs;
        for (const auto& [_, t] : tools_) defs.push_back(t->definition());
        return defs;
    }

    ToolCallResult execute(const std::string& name,
                           const std::map<std::string, std::string>& params) {
        auto id = std::format("call_{}", nextCallId_++);
        auto start = std::chrono::steady_clock::now();

        auto it = tools_.find(name);
        if (it == tools_.end()) {
            return {id, name, std::format("Tool '{}' not found", name),
                    true, std::chrono::milliseconds{0}};
        }

        // Validate required params
        for (const auto& p : it->second->definition().params) {
            if (p.required && !params.contains(p.name)) {
                return {id, name,
                        std::format("Missing required param: '{}'", p.name),
                        true, std::chrono::milliseconds{0}};
            }
        }

        try {
            auto output = it->second->execute(params);
            auto dur = std::chrono::duration_cast<std::chrono::milliseconds>(
                std::chrono::steady_clock::now() - start);
            return {id, name, std::move(output), false, dur};
        } catch (const std::exception& e) {
            auto dur = std::chrono::duration_cast<std::chrono::milliseconds>(
                std::chrono::steady_clock::now() - start);
            return {id, name, e.what(), true, dur};
        }
    }
};

// [step] Implement a Tool-Use agent with conversation history
struct Message {
    std::string role;   // "user", "assistant", "tool"
    std::string content;
    std::optional<std::string> toolCallId;
};

struct LLMResponse {
    std::string content;
    struct ToolCall {
        std::string name;
        std::map<std::string, std::string> params;
    };
    std::optional<ToolCall> toolCall;
};

using LLMFn = std::function<LLMResponse(const std::vector<Message>&,
                                         const std::vector<ToolDefinition>&)>;

class ToolUseAgent {
    ToolRegistry registry_;
    LLMFn llm_;
    std::vector<Message> history_;
    int maxIterations_;

public:
    ToolUseAgent(LLMFn llm, int maxIter = 15)
        : llm_(std::move(llm)), maxIterations_(maxIter) {}

    void registerTool(std::unique_ptr<ITool> tool) {
        registry_.registerTool(std::move(tool));
    }

    std::string run(const std::string& userMessage) {
        history_.push_back({"user", userMessage, std::nullopt});

        for (int i = 0; i < maxIterations_; ++i) {
            auto response = llm_(history_, registry_.definitions());

            if (!response.toolCall) {
                history_.push_back({"assistant", response.content, std::nullopt});
                return response.content;
            }

            auto result = registry_.execute(response.toolCall->name,
                                            response.toolCall->params);
            history_.push_back({"assistant",
                std::format("Calling {}", response.toolCall->name),
                result.callId});
            history_.push_back({"tool",
                result.isError ? "Error: " + result.output : result.output,
                result.callId});
        }
        throw std::runtime_error("Exceeded max tool-use iterations");
    }
};

// [step] Demo with a concrete calculator tool
class CalculatorTool : public ITool {
public:
    ToolDefinition definition() const override {
        return {"calculator", "Evaluates arithmetic",
                {{"expr", "string", "Expression", true}}};
    }
    std::string execute(const std::map<std::string, std::string>& params) override {
        // Simplified: only handles "a+b"
        auto expr = params.at("expr");
        auto pos = expr.find('+');
        if (pos == std::string::npos) throw std::runtime_error("Unsupported expr");
        int a = std::stoi(expr.substr(0, pos));
        int b = std::stoi(expr.substr(pos + 1));
        return std::to_string(a + b);
    }
};

int main() {
    ToolUseAgent agent(
        [n = 0](const std::vector<Message>& hist,
                const std::vector<ToolDefinition>&) mutable -> LLMResponse {
            if (++n > 1) return {"The answer is 8", std::nullopt};
            return {"", LLMResponse::ToolCall{"calculator", {{"expr", "3+5"}}}};
        }
    );
    agent.registerTool(std::make_unique<CalculatorTool>());
    std::cout << agent.run("What is 3+5?") << "\n";
}