node.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/run_context.h>
#include <neograph/graph/types.h>
#include <neograph/graph/state.h>
#include <neograph/runtime_interposition_consumer.h>
 
#include <asio/awaitable.hpp>
 
#include <stdexcept>
#include <mutex>
#include <set>
#include <string_view>
 
namespace neograph { class RuntimeInterpositionController; }
namespace neograph::graph {
 
struct NodeInput {
    const GraphState&  state;
 
    const RunContext&  ctx;
 
    const GraphStreamCallback* stream_cb = nullptr;
};
 
using NodeOutput = NodeResult;
 
class NEOGRAPH_API GraphNode {
public:
    virtual ~GraphNode() = default;
 
    virtual asio::awaitable<NodeOutput> run(NodeInput in) = 0;
 
    virtual std::string get_name() const = 0;
};
 
class NEOGRAPH_API SyncGraphNode : public GraphNode {
public:
    explicit SyncGraphNode(std::string name);
    ~SyncGraphNode() override;
 
    asio::awaitable<NodeOutput> run(NodeInput in) final;
    std::string get_name() const final;
 
protected:
    virtual NodeOutput run_sync(NodeInput in) = 0;
 
private:
    std::string name_;
};
 
class NEOGRAPH_API LLMCallNode : public GraphNode, public ::neograph::RuntimeInterpositionConsumer {
public:
    LLMCallNode(const std::string& name, const NodeContext& ctx);
 
    asio::awaitable<NodeOutput> run(NodeInput in) override;
 
    std::string get_name() const override { return name_; }
 
    bool has_provider() const noexcept { return provider_ != nullptr; }
 
private:
    std::string              name_;
    std::shared_ptr<Provider> provider_;
    ToolSet                 tools_owner_;
    std::vector<Tool*>       tools_;
    std::string              model_;
    std::string              instructions_;
    ProviderControls controls_;
 
    ProviderRequest build_params(const GraphState& state) const;
};
 
class NEOGRAPH_API ToolDispatchNode : public GraphNode {
public:
    ToolDispatchNode(const std::string& name, const NodeContext& ctx);
 
    asio::awaitable<NodeOutput> run(NodeInput in) override;
    std::string get_name() const override { return name_; }
 
private:
    std::string        name_;
    ToolSet           tools_owner_;
    std::vector<Tool*> tools_;
};
 
// Forward declaration
class GraphEngine;
 
class NEOGRAPH_API IntentClassifierNode : public GraphNode, public ::neograph::RuntimeInterpositionConsumer {
public:
    IntentClassifierNode(const std::string& name, const NodeContext& ctx,
                         const std::string& prompt,
                         std::vector<std::string> valid_routes);
 
    asio::awaitable<NodeOutput> run(NodeInput in) override;
    std::string get_name() const override { return name_; }
 
    bool has_provider() const noexcept { return provider_ != nullptr; }
 
private:
    std::string               name_;
    std::shared_ptr<Provider>  provider_;
    std::string               model_;
    std::string               prompt_;
    std::vector<std::string>  valid_routes_;
    ProviderControls          controls_;  
 
    ProviderRequest build_params(const GraphState& state) const;
    std::vector<ChannelWrite> route_from(const std::string& intent) const;
};
 
enum class SubgraphPersistence {
    Legacy,         
    PerInvocation,  
    PerThread,      
    Stateless       
};
 
class NEOGRAPH_API SubgraphNode : public GraphNode {
public:
    SubgraphNode(const std::string& name,
                 std::shared_ptr<GraphEngine> subgraph,
                 std::map<std::string, std::string> input_map = {},
                 std::map<std::string, std::string> output_map = {},
                 SubgraphPersistence persistence = SubgraphPersistence::Legacy);
 
    SubgraphPersistence persistence() const noexcept { return persistence_; }
    const GraphEngine& child_engine() const noexcept { return *subgraph_; }
    std::string checkpoint_thread_id(
        const std::string& parent_thread_id, int parent_step,
        std::string_view task_id,
        std::string_view graph_invocation_id = {}) const;
 
    asio::awaitable<NodeOutput> run(NodeInput in) override;
    std::string get_name() const override { return name_; }
 
private:
    std::string name_;
    std::shared_ptr<GraphEngine> subgraph_;
    std::map<std::string, std::string> input_map_;
    std::map<std::string, std::string> output_map_;
    SubgraphPersistence persistence_;
    std::mutex active_mutex_;
    std::set<std::string> active_per_thread_;
 
    json build_subgraph_input(const GraphState& state) const;
    std::vector<ChannelWrite> map_output_writes(
        const std::vector<ChannelWrite>& child_writes) const;
};
 
} // namespace neograph::graph