tool_dispatch.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/types.h>
#include <neograph/tool.h>
 
#include <asio/awaitable.hpp>
 
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace neograph {
 
struct ToolGateContext {
    std::optional<json> resume_value;
 
    std::string thread_id;
 
    int step = 0;
 
    std::shared_ptr<const std::vector<ToolCall>> batch_calls;
};
 
struct ToolDecision {
    enum class Kind {
        Allow,      
        Deny,       
        Interrupt   
    };
 
    Kind kind = Kind::Allow;
 
    std::optional<json> args;
 
    std::string reason;
 
    std::optional<json> payload;
 
    static ToolDecision allow() { return ToolDecision{}; }
 
    static ToolDecision allow(json rewritten_args) {
        ToolDecision d;
        d.args = std::move(rewritten_args);
        return d;
    }
 
    static ToolDecision deny(std::string reason) {
        ToolDecision d;
        d.kind   = Kind::Deny;
        d.reason = std::move(reason);
        return d;
    }
 
    static ToolDecision interrupt(std::string reason) {
        ToolDecision d;
        d.kind   = Kind::Interrupt;
        d.reason = std::move(reason);
        return d;
    }
 
    static ToolDecision interrupt(std::string reason, json payload) {
        ToolDecision d;
        d.kind    = Kind::Interrupt;
        d.reason  = std::move(reason);
        d.payload = std::move(payload);
        return d;
    }
};
 
using ToolGate =
    std::function<asio::awaitable<ToolDecision>(ToolCall, ToolGateContext)>;
 
NEOGRAPH_API asio::awaitable<std::vector<ChatMessage>>
dispatch_tool_calls(std::vector<ToolCall> calls, std::vector<Tool*> tools,
                    ToolGate gate = {}, ToolGateContext gctx = {},
                    ToolExecutionContext execution = {});
 
}  // namespace neograph