tool_service.h

// neograph::grpc — single-tool-call gRPC service + remote-tool client.
//
// Two mirror halves of the same `ToolService.CallTool` RPC:
//
//   * run_tool_server  — SERVE local C++ functions over gRPC (the fair
//     gRPC counterpart of MCP's JSON-RPC 2.0 `tools/call`; example 55).
//   * GrpcRemoteTool    — CONSUME a remote ToolService method as an
//     ordinary neograph::Tool, so an Agent/ReAct loop can call a tool
//     that lives in another process/language with no code change on
//     the agent side (example 57).
//
// Opt-in (NEOGRAPH_BUILD_GRPC). Whole header behind NEOGRAPH_HAVE_GRPC
// so the umbrella include never pulls grpc++.
//
// make_tool_service() returns a std::unique_ptr<::grpc::Service>, which the
// caller destroys: the header therefore includes the gRPC service base
// (<grpcpp/impl/service_type.h>), and including it alone is enough to build
// and destroy the service. The generated neograph.grpc.pb.h is not needed.
 
#pragma once
 
#ifdef NEOGRAPH_HAVE_GRPC
 
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
 
// ::grpc::Service, complete for the destructor of the returned unique_ptr.
#if __has_include(<grpcpp/impl/service_type.h>)
#include <grpcpp/impl/service_type.h>
#else
#include <grpcpp/impl/codegen/service_type.h>
#endif
 
#include <neograph/api.h>   // NEOGRAPH_API
#include <neograph/grpc/serve_options.h>
#include <neograph/tool.h>  // neograph::Tool, ChatTool, json
 
#include <asio/awaitable.hpp>
 
namespace neograph::grpc {
 
using ToolFn = std::function<std::string(const std::string&)>;
 
NEOGRAPH_API std::unique_ptr<::grpc::Service> make_tool_service(
    std::unordered_map<std::string, ToolFn> tools);
 
NEOGRAPH_API void run_tool_server(
    const std::string& address,
    std::unordered_map<std::string, ToolFn> tools);
NEOGRAPH_API void run_tool_server(
    const std::string& address,
    std::unordered_map<std::string, ToolFn> tools,
    const ServeOptions& options);
 
class NEOGRAPH_API GrpcRemoteTool : public neograph::Tool,
                                     public neograph::ContextualAsyncTool {
public:
    GrpcRemoteTool(const std::string& target,
                   std::string name,
                   std::string description,
                   neograph::json parameters);
    ~GrpcRemoteTool() override;
 
    ChatTool get_definition() const override;
    std::string execute(const neograph::json& arguments) override;
    asio::awaitable<std::string> execute_async(
        const neograph::json& arguments, neograph::ToolExecutionContext context) override;
    std::string get_name() const override;
 
    void set_call_timeout(std::chrono::milliseconds timeout);
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace neograph::grpc
 
#endif  // NEOGRAPH_HAVE_GRPC