types.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/types.h>
#include <neograph/provider.h>
#include <neograph/tool.h>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>
#include <cstdint>
 
// Windows SDK (pulled in transitively via asio on Win32) defines a
// bunch of ALL-CAPS macros — notably ERROR (wingdi.h) and DEBUG —
// that silently clobber enumerator names. `enum class Type { ERROR }`
// below becomes `enum class Type { 0 }` and every downstream parse
// collapses. Scrub the ones we actually use before declaring the
// enums. No-op outside of Windows.
#ifdef _WIN32
#  ifdef ERROR
#    undef ERROR
#  endif
#  ifdef DEBUG
#    undef DEBUG
#  endif
#  ifdef IN
#    undef IN
#  endif
#  ifdef OUT
#    undef OUT
#  endif
#endif
 
namespace neograph::graph {
 
// Forward declaration
class GraphState;
 
enum class ReducerType {
    OVERWRITE,  
    APPEND,     
    CUSTOM      
};
 
using ReducerFn = std::function<json(const json& current, const json& incoming)>;
 
struct Channel {
    std::string name;                                
    ReducerType reducer_type = ReducerType::OVERWRITE; 
    ReducerFn   reducer;                             
    json        value;                               
    uint64_t    version = 0;                         
};
 
struct ChannelWrite {
    std::string channel;  
    json        value;    
};
 
class NEOGRAPH_API NodeInterrupt : public std::runtime_error {
public:
    explicit NodeInterrupt(const std::string& reason)
        : std::runtime_error(reason), reason_(reason) {}
 
    const std::string& reason() const { return reason_; }
private:
    std::string reason_;
};
 
struct Send {
    std::string target_node;  
    json        input;        
};
 
struct Command {
    std::string                goto_node;  
    std::vector<ChannelWrite>  updates;    
};
 
struct RetryPolicy {
    int    max_retries      = 0;       
    int    initial_delay_ms = 100;     
    float  backoff_multiplier = 2.0f;  
    int    max_delay_ms     = 5000;    
    float  jitter_pct       = 0.0f;
};
 
enum class StreamMode : uint8_t {
    EVENTS   = 0x01,  
    TOKENS   = 0x02,  
    VALUES   = 0x04,  
    UPDATES  = 0x08,  
    DEBUG    = 0x10,  
    ALL      = 0xFF   
};
 
inline StreamMode operator|(StreamMode a, StreamMode b) {
    return static_cast<StreamMode>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
}
inline StreamMode operator&(StreamMode a, StreamMode b) {
    return static_cast<StreamMode>(static_cast<uint8_t>(a) & static_cast<uint8_t>(b));
}
inline bool has_mode(StreamMode flags, StreamMode test) {
    return static_cast<uint8_t>(flags & test) != 0;
}
 
struct Edge {
    std::string from;  
    std::string to;    
};
 
struct ConditionalEdge {
    std::string from;                                
    std::string condition;                           
    std::map<std::string, std::string> routes;       
};
 
struct NodeContext {
    std::shared_ptr<Provider> provider;    
    std::vector<Tool*>        tools;
    std::string               model;       
    std::string               instructions; 
    json                      extra_config; 
};
 
struct GraphEvent {
    enum class Type {
        NODE_START,     
        NODE_END,       
        LLM_TOKEN,      
        CHANNEL_WRITE,  
        INTERRUPT,      
        ERROR           
    };
    Type        type;       
    std::string node_name;  
    json        data;       
};
 
using GraphStreamCallback = std::function<void(const GraphEvent&)>;
 
struct NodeResult {
    std::vector<ChannelWrite> writes;          
    std::optional<Command>    command;          
    std::vector<Send>         sends;           
 
    NodeResult() = default;
 
    NodeResult(std::vector<ChannelWrite> w) : writes(std::move(w)) {}
};
 
using ConditionFn = std::function<std::string(const GraphState&)>;
 
constexpr const char* START_NODE = "__start__";
constexpr const char* END_NODE   = "__end__";
 
} // namespace neograph::graph