tool.hpp

Go to the documentation of this file.

// Copyright 2026 Aniket Kulkarni
// SPDX-License-Identifier: Apache-2.0
 
 
#pragma once
 
#include "neuralplus/export.hpp"
#include "neuralplus/session.hpp"
#include "neuralplus/types.hpp"
 
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <utility>
#include <vector>
 
namespace neuralplus {
 
class AIClient;
 
class NEURALPLUS_API ToolContext final {
public:
    ToolContext(std::string session_id,
                std::string run_id,
                std::string call_id,
                SessionState& state);
 
    [[nodiscard]] const std::string& session_id() const noexcept;
 
    [[nodiscard]] const std::string& run_id() const noexcept;
 
    [[nodiscard]] const std::string& call_id() const noexcept;
 
    [[nodiscard]] SessionState& state() const noexcept;
 
private:
    ToolContext(const ToolContext&) = delete;
    ToolContext& operator=(const ToolContext&) = delete;
 
    std::string session_id_;
    std::string run_id_;
    std::string call_id_;
    SessionState* state_;
};
 
struct NEURALPLUS_API ToolOutput {
    std::vector<Content> contents;
 
    bool is_error{false};
 
    [[nodiscard]] static ToolOutput text(std::string value);
 
    [[nodiscard]] static ToolOutput json(JsonValue value);
 
    [[nodiscard]] static ToolOutput error(std::string value);
};
 
class NEURALPLUS_API Tool {
public:
    virtual ~Tool();
 
    [[nodiscard]] virtual const ToolSpec& spec() const noexcept = 0;
 
    virtual ToolOutput invoke(ToolContext& context,
                              const JsonValue& arguments) = 0;
 
protected:
    Tool() = default;
 
private:
    friend class AIClient;
 
    Tool(const Tool&) = delete;
    Tool& operator=(const Tool&) = delete;
 
    mutable std::recursive_mutex invocation_mutex_;
};
 
class NEURALPLUS_API FunctionTool final : public Tool {
public:
    using Function = std::function<ToolOutput(ToolContext&, const JsonValue&)>;
 
    FunctionTool(ToolSpec spec, Function function);
    ~FunctionTool() override;
 
    [[nodiscard]] const ToolSpec& spec() const noexcept override;
 
    ToolOutput invoke(ToolContext& context,
                      const JsonValue& arguments) override;
 
private:
    FunctionTool(const FunctionTool&) = delete;
    FunctionTool& operator=(const FunctionTool&) = delete;
 
    ToolSpec spec_;
    Function function_;
};
 
using Tools = std::vector<std::shared_ptr<Tool>>;
 
}  // namespace neuralplus