openai_provider.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/provider.h>
#include <asio/executor_work_guard.hpp>
#include <asio/io_context.hpp>
#include <memory>
#include <optional>
#include <string>
#include <thread>
 
namespace neograph::async { class ConnPool; }
 
namespace neograph::llm {
 
class NEOGRAPH_API OpenAIProvider : public Provider {
  public:
    struct Config {
        std::string api_key;                              
        std::string base_url = "https://api.openai.com";  
        std::string default_model = "gpt-4o-mini";        
        int timeout_seconds = 60;
    };
 
    static std::unique_ptr<OpenAIProvider> create(const Config& config);
 
    static std::shared_ptr<Provider> create_shared(const Config& config);
 
    ~OpenAIProvider();
 
    asio::awaitable<ChatCompletion>
    complete_async(const CompletionParams& params) override;
 
 
    ChatCompletion complete_stream(const CompletionParams& params,
                                   const StreamCallback& on_chunk) override;
 
    asio::awaitable<ChatCompletion>
    invoke(const CompletionParams& params, StreamCallback on_chunk) override;
 
    std::string get_name() const override { return "openai"; }
 
  private:
    explicit OpenAIProvider(Config config);
    json build_body(const CompletionParams& params) const;
    Config config_;
 
    // Long-lived HTTP loop + ConnPool. Same shape as SchemaProvider —
    // see commit 6da4810 / feedback_schema_provider_no_pool. ConnPool
    // can't live inside Provider::complete()'s run_sync io_context
    // (one-shot), so the provider owns its own io_context + worker.
    std::unique_ptr<asio::io_context> http_io_;
    std::optional<asio::executor_work_guard<asio::io_context::executor_type>> http_work_;
    std::thread http_thread_;
    std::unique_ptr<async::ConnPool> conn_pool_;
};
 
} // namespace neograph::llm