ai_service_connector::impl Class Reference

Collaboration diagram for ai_service_connector::impl:

Public Member Functions
	impl ()=default
	~impl ()
auto	initialize (const ai_service_config &config) -> Result< std::monostate >
void	shutdown ()
bool	is_initialized () const noexcept
auto	request_inference (const inference_request &request) -> Result< std::string >
auto	check_status (const std::string &job_id) -> Result< inference_status >
auto	cancel (const std::string &job_id) -> Result< std::monostate >
auto	wait_for_completion (const std::string &job_id, std::chrono::milliseconds timeout, status_callback callback) -> Result< inference_status >
auto	list_active_jobs () -> Result< std::vector< inference_status > >
auto	list_models () -> Result< std::vector< model_info > >
auto	get_model_info (const std::string &model_id) -> Result< model_info >
bool	check_health ()
auto	get_latency () -> std::optional< std::chrono::milliseconds >
const ai_service_config &	get_config () const
auto	update_credentials (authentication_type auth_type, const std::string &credentials) -> Result< std::monostate >

Private Attributes
std::mutex	mutex_
std::atomic< bool >	initialized_ {false}
ai_service_config	config_
std::unique_ptr< http_client >	http_client_
std::unique_ptr< job_tracker >	job_tracker_

Detailed Description

Definition at line 899 of file ai_service_connector.cpp.

Constructor & Destructor Documentation

impl()

ai_service_connector::impl::impl ( )

default

~impl()

ai_service_connector::impl::~impl ( )

inline

Definition at line 903 of file ai_service_connector.cpp.

            {
        shutdown();
    }

Member Function Documentation

cancel()

auto ai_service_connector::impl::cancel ( const std::string & job_id ) -> Result<std::monostate>

inline

Definition at line 1055 of file ai_service_connector.cpp.

                                                                 {
        if (!initialized_) {
            return error_info(-1, "AI service connector not initialized", "ai_service_connector");
        }
 
        auto response = http_client_->del("/inference/" + job_id);
        if (response.is_err()) {
            return response.error();
        }
 
        if (!response.value().is_success() && response.value().status_code != 404) {
            return error_info(
                response.value().status_code,
                "Failed to cancel job",
                "ai_service_connector");
        }
 
        // Update local status
        inference_status status;
        status.job_id = job_id;
        status.status = inference_status_code::cancelled;
        status.message = "Job cancelled by user";
        status.completed_at = std::chrono::system_clock::now();
        job_tracker_->update_status(job_id, status);
 
        kcenon::pacs::integration::logger_adapter::info("Inference job cancelled: {}", job_id);
 
        return std::monostate{};
    }

References kcenon::pacs::integration::logger_adapter::info().

Here is the call graph for this function:

check_health()

bool ai_service_connector::impl::check_health ( )

inlinenodiscard

Definition at line 1193 of file ai_service_connector.cpp.

                                      {
        if (!initialized_ || !http_client_) {
            return false;
        }
        return http_client_->check_connectivity();
    }

check_status()

auto ai_service_connector::impl::check_status ( const std::string & job_id ) -> Result<inference_status>

inline

Definition at line 1014 of file ai_service_connector.cpp.

                                                                           {
        if (!initialized_) {
            return error_info(-1, "AI service connector not initialized", "ai_service_connector");
        }
 
        // Check local cache first
        auto cached = job_tracker_->get_status(job_id);
        if (cached && (cached->status == inference_status_code::completed ||
                       cached->status == inference_status_code::failed ||
                       cached->status == inference_status_code::cancelled)) {
            return *cached;
        }
 
        // Query remote service
        auto response = http_client_->get("/inference/" + job_id);
        if (response.is_err()) {
            return response.error();
        }
 
        if (!response.value().is_success()) {
            if (response.value().status_code == 404) {
                return error_info(404, "Job not found: " + job_id, "ai_service_connector");
            }
            return error_info(
                response.value().status_code,
                "Failed to get job status",
                "ai_service_connector");
        }
 
        // Parse status
        auto status = json_util::parse_status_json(response.value().body);
        if (!status) {
            return error_info(-1, "Failed to parse status response", "ai_service_connector");
        }
 
        // Update local cache
        job_tracker_->update_status(job_id, *status);
 
        return *status;
    }

get_config()

const ai_service_config & ai_service_connector::impl::get_config ( ) const

inlinenodiscard

Definition at line 1207 of file ai_service_connector.cpp.

                                                              {
        return config_;
    }

get_latency()

auto ai_service_connector::impl::get_latency ( ) -> std::optional<std::chrono::milliseconds>

inlinenodiscard

Definition at line 1200 of file ai_service_connector.cpp.

                                                                           {
        if (!initialized_ || !http_client_) {
            return std::nullopt;
        }
        return http_client_->measure_latency();
    }

get_model_info()

auto ai_service_connector::impl::get_model_info ( const std::string & model_id ) -> Result<model_info>

inline

Definition at line 1168 of file ai_service_connector.cpp.

                                                                         {
        if (!initialized_) {
            return error_info(-1, "AI service connector not initialized", "ai_service_connector");
        }
 
        auto response = http_client_->get("/models/" + model_id);
        if (response.is_err()) {
            return response.error();
        }
 
        if (!response.value().is_success()) {
            return error_info(
                response.value().status_code,
                "Failed to get model info",
                "ai_service_connector");
        }
 
        auto info = json_util::parse_model_json(response.value().body);
        if (!info) {
            return error_info(-1, "Failed to parse model info", "ai_service_connector");
        }
 
        return *info;
    }

initialize()

auto ai_service_connector::impl::initialize ( const ai_service_config & config ) -> Result<std::monostate>

inline

Definition at line 907 of file ai_service_connector.cpp.

                                                                             {
        std::lock_guard lock(mutex_);
 
        if (initialized_) {
            return std::monostate{};
        }
 
        config_ = config;
 
        // Validate configuration
        if (config.base_url.empty()) {
            return error_info(-1, "Base URL is required", "ai_service_connector");
        }
 
        // Initialize HTTP client
        http_client_ = std::make_unique<http_client>(config);
 
        // Test connectivity
        if (!http_client_->check_connectivity()) {
            kcenon::pacs::integration::logger_adapter::warn(
                "AI service at {} is not responding, continuing anyway",
                config.base_url);
        }
 
        // Initialize job tracker
        job_tracker_ = std::make_unique<job_tracker>();
 
        // Initialize metrics
        kcenon::pacs::integration::monitoring_adapter::set_gauge(metrics::active_jobs, 0);
 
        kcenon::pacs::integration::logger_adapter::info(
            "AI service connector initialized: url={}, auth={}",
            config.base_url, to_string(config.auth_type));
 
        initialized_ = true;
        return std::monostate{};
    }

References kcenon::pacs::integration::logger_adapter::info(), kcenon::pacs::integration::monitoring_adapter::set_gauge(), and kcenon::pacs::integration::logger_adapter::warn().

Here is the call graph for this function:

is_initialized()

bool ai_service_connector::impl::is_initialized ( ) const

inlinenodiscardnoexcept

Definition at line 959 of file ai_service_connector.cpp.

                                                       {
        return initialized_.load();
    }

list_active_jobs()

auto ai_service_connector::impl::list_active_jobs ( ) -> Result<std::vector<inference_status>>

inline

Definition at line 1128 of file ai_service_connector.cpp.

                                                                   {
        if (!initialized_) {
            return error_info(-1, "AI service connector not initialized", "ai_service_connector");
        }
 
        return job_tracker_->get_active_jobs();
    }

list_models()

auto ai_service_connector::impl::list_models ( ) -> Result<std::vector<model_info>>

inline

Definition at line 1136 of file ai_service_connector.cpp.

                                                        {
        if (!initialized_) {
            return error_info(-1, "AI service connector not initialized", "ai_service_connector");
        }
 
        auto response = http_client_->get("/models");
        if (response.is_err()) {
            return response.error();
        }
 
        if (!response.value().is_success()) {
            return error_info(
                response.value().status_code,
                "Failed to list models",
                "ai_service_connector");
        }
 
        // Parse models array from JSON response
        std::vector<model_info> models;
        auto model_objects = json_util::extract_json_array_objects(
            response.value().body);
 
        for (const auto& obj : model_objects) {
            auto info = json_util::parse_model_json(obj);
            if (info) {
                models.push_back(std::move(*info));
            }
        }
 
        return models;
    }

request_inference()

auto ai_service_connector::impl::request_inference ( const inference_request & request ) -> Result<std::string>

inline

Definition at line 963 of file ai_service_connector.cpp.

                                                                                  {
        if (!initialized_) {
            return error_info(-1, "AI service connector not initialized", "ai_service_connector");
        }
 
        // Validate request
        if (request.study_instance_uid.empty()) {
            return error_info(-1, "Study Instance UID is required", "ai_service_connector");
        }
        if (request.model_id.empty()) {
            return error_info(-1, "Model ID is required", "ai_service_connector");
        }
 
        // Build request JSON
        std::string body = json_util::build_request_json(request);
 
        // Send request
        auto response = http_client_->post("/inference", body);
        if (response.is_err()) {
            kcenon::pacs::integration::logger_adapter::error(
                "Failed to submit inference request: {}",
                response.error().message);
            return response.error();
        }
 
        if (!response.value().is_success()) {
            return error_info(
                response.value().status_code,
                "AI service returned error: " + response.value().body,
                "ai_service_connector");
        }
 
        // Parse response to get job ID
        auto job_id = json_util::extract_string(response.value().body, "job_id");
        if (!job_id) {
            return error_info(-1, "Failed to parse job ID from response", "ai_service_connector");
        }
 
        // Track the job
        job_tracker_->add_job(*job_id, request);
 
        kcenon::pacs::integration::logger_adapter::info(
            "Inference request submitted: job_id={}, study={}, model={}",
            *job_id, request.study_instance_uid, request.model_id);
 
        kcenon::pacs::integration::monitoring_adapter::increment_counter(
            metrics::inference_requests_total);
 
        return *job_id;
    }

References kcenon::pacs::integration::logger_adapter::error(), kcenon::pacs::integration::monitoring_adapter::increment_counter(), kcenon::pacs::integration::logger_adapter::info(), kcenon::pacs::ai::inference_request::model_id, and kcenon::pacs::ai::inference_request::study_instance_uid.

Here is the call graph for this function:

shutdown()

void ai_service_connector::impl::shutdown ( )

inline

Definition at line 945 of file ai_service_connector.cpp.

                    {
        std::lock_guard lock(mutex_);
 
        if (!initialized_) {
            return;
        }
 
        kcenon::pacs::integration::logger_adapter::info("AI service connector shutting down");
 
        http_client_.reset();
        job_tracker_.reset();
        initialized_ = false;
    }

References kcenon::pacs::integration::logger_adapter::info().

Here is the call graph for this function:

update_credentials()

auto ai_service_connector::impl::update_credentials ( authentication_type auth_type, const std::string & credentials ) -> Result<std::monostate>

inline

Definition at line 1211 of file ai_service_connector.cpp.

                                                                                  {
        std::lock_guard lock(mutex_);
 
        config_.auth_type = auth_type;
 
        switch (auth_type) {
            case authentication_type::api_key:
                config_.api_key = credentials;
                break;
            case authentication_type::bearer_token:
                config_.bearer_token = credentials;
                break;
            case authentication_type::basic: {
                auto colon_pos = credentials.find(':');
                if (colon_pos != std::string::npos) {
                    config_.username = credentials.substr(0, colon_pos);
                    config_.password = credentials.substr(colon_pos + 1);
                } else {
                    return error_info(-1, "Basic auth credentials must be in format 'username:password'",
                                      "ai_service_connector");
                }
                break;
            }
            case authentication_type::none:
                break;
        }
 
        // Recreate HTTP client with new credentials
        http_client_ = std::make_unique<http_client>(config_);
 
        kcenon::pacs::integration::logger_adapter::info(
            "AI service credentials updated: auth={}",
            to_string(auth_type));
 
        return std::monostate{};
    }

References kcenon::pacs::integration::logger_adapter::info().

Here is the call graph for this function:

wait_for_completion()

auto ai_service_connector::impl::wait_for_completion ( const std::string & job_id, std::chrono::milliseconds timeout, status_callback callback ) -> Result<inference_status>

inline

Definition at line 1085 of file ai_service_connector.cpp.

                                                                                   {
        if (!initialized_) {
            return error_info(-1, "AI service connector not initialized", "ai_service_connector");
        }
 
        auto start_time = std::chrono::steady_clock::now();
        auto deadline = start_time + timeout;
 
        while (std::chrono::steady_clock::now() < deadline) {
            auto result = check_status(job_id);
            if (result.is_err()) {
                return result;
            }
 
            auto& status = result.value();
 
            // Call callback if provided
            if (callback) {
                callback(status);
            }
 
            // Check if job is complete
            if (status.status == inference_status_code::completed ||
                status.status == inference_status_code::failed ||
                status.status == inference_status_code::cancelled ||
                status.status == inference_status_code::timeout) {
                return status;
            }
 
            // Wait before polling again
            std::this_thread::sleep_for(config_.polling_interval);
        }
 
        // Timeout
        inference_status timeout_status;
        timeout_status.job_id = job_id;
        timeout_status.status = inference_status_code::timeout;
        timeout_status.message = "Timed out waiting for job completion";
        return timeout_status;
    }

Member Data Documentation

config_

ai_service_config ai_service_connector::impl::config_

private

Definition at line 1252 of file ai_service_connector.cpp.

http_client_

std::unique_ptr<http_client> ai_service_connector::impl::http_client_

private

Definition at line 1253 of file ai_service_connector.cpp.

initialized_

std::atomic<bool> ai_service_connector::impl::initialized_ {false}

private

Definition at line 1251 of file ai_service_connector.cpp.

{false};

job_tracker_

std::unique_ptr<job_tracker> ai_service_connector::impl::job_tracker_

private

Definition at line 1254 of file ai_service_connector.cpp.

mutex_

std::mutex ai_service_connector::impl::mutex_

mutableprivate

Definition at line 1250 of file ai_service_connector.cpp.

---

The documentation for this class was generated from the following file:

• src/ai/ai_service_connector.cpp