ai_service_connector.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <filesystem>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
// KCENON_HAS_COMMON_SYSTEM is defined by CMake when common_system is available
#ifndef KCENON_HAS_COMMON_SYSTEM
#define KCENON_HAS_COMMON_SYSTEM 0
#endif
 
#if KCENON_HAS_COMMON_SYSTEM
#include <kcenon/common/patterns/result.h>
#endif
 
namespace kcenon::pacs::ai {
 
// =============================================================================
// Result Type (fallback when common_system is unavailable)
// =============================================================================
 
#if KCENON_HAS_COMMON_SYSTEM
template <typename T>
using Result = kcenon::common::Result<T>;
 
using error_info = kcenon::common::error_info;
#else
struct error_info {
    int code = -1;
    std::string message;
    std::string module;
 
    error_info() = default;
    explicit error_info(const std::string& msg) : message(msg) {}
    error_info(int c, const std::string& msg, const std::string& mod = "")
        : code(c), message(msg), module(mod) {}
};
 
template <typename T>
class Result {
public:
    Result(T value) : data_(std::move(value)), has_value_(true) {}
    Result(const error_info& err) : error_(err), has_value_(false) {}
 
    [[nodiscard]] bool is_ok() const noexcept { return has_value_; }
    [[nodiscard]] bool is_err() const noexcept { return !has_value_; }
    [[nodiscard]] T& value() & { return data_; }
    [[nodiscard]] const T& value() const& { return data_; }
    [[nodiscard]] T&& value() && { return std::move(data_); }
    [[nodiscard]] const error_info& error() const { return error_; }
 
private:
    T data_{};
    error_info error_;
    bool has_value_;
};
#endif
 
// =============================================================================
// Enumerations
// =============================================================================
 
enum class inference_status_code {
    pending,      
    running,      
    completed,    
    failed,       
    cancelled,    
    timeout       
};
 
enum class authentication_type {
    none,         
    api_key,      
    bearer_token, 
    basic         
};
 
// =============================================================================
// Configuration Structures
// =============================================================================
 
struct ai_service_config {
    std::string base_url;
 
    std::string service_name{"ai_service"};
 
    authentication_type auth_type{authentication_type::none};
 
    std::string api_key;
 
    std::string username;
 
    std::string password;
 
    std::string bearer_token;
 
    std::chrono::milliseconds connection_timeout{30000};
 
    std::chrono::milliseconds request_timeout{300000};  // 5 minutes
 
    std::size_t max_retries{3};
 
    std::chrono::milliseconds retry_delay{1000};
 
    bool verify_ssl{true};
 
    std::optional<std::filesystem::path> ca_cert_path;
 
    std::chrono::milliseconds polling_interval{5000};
};
 
struct inference_request {
    std::string study_instance_uid;
 
    std::optional<std::string> series_instance_uid;
 
    std::string model_id;
 
    std::map<std::string, std::string> parameters;
 
    int priority{0};
 
    std::optional<std::string> callback_url;
 
    std::map<std::string, std::string> metadata;
};
 
struct inference_status {
    std::string job_id;
 
    inference_status_code status{inference_status_code::pending};
 
    int progress{0};
 
    std::string message;
 
    std::optional<std::string> error_message;
 
    std::chrono::system_clock::time_point created_at;
 
    std::optional<std::chrono::system_clock::time_point> started_at;
 
    std::optional<std::chrono::system_clock::time_point> completed_at;
 
    std::vector<std::string> result_uids;
};
 
struct model_info {
    std::string model_id;
 
    std::string name;
 
    std::string description;
 
    std::string version;
 
    std::vector<std::string> supported_modalities;
 
    std::vector<std::string> supported_sop_classes;
 
    std::vector<std::string> output_types;
 
    bool available{true};
};
 
// =============================================================================
// AI Service Connector Class
// =============================================================================
 
class ai_service_connector {
public:
    // =========================================================================
    // Type Aliases
    // =========================================================================
 
    using status_callback = std::function<void(const inference_status&)>;
 
    using completion_callback = std::function<void(const std::string& job_id,
                                                   bool success,
                                                   const std::vector<std::string>& result_uids)>;
 
    // =========================================================================
    // Initialization
    // =========================================================================
 
    [[nodiscard]] static auto initialize(const ai_service_config& config)
        -> Result<std::monostate>;
 
    static void shutdown();
 
    [[nodiscard]] static auto is_initialized() noexcept -> bool;
 
    // =========================================================================
    // Inference Operations
    // =========================================================================
 
    [[nodiscard]] static auto request_inference(const inference_request& request)
        -> Result<std::string>;
 
    [[nodiscard]] static auto check_status(const std::string& job_id)
        -> Result<inference_status>;
 
    [[nodiscard]] static auto cancel(const std::string& job_id)
        -> Result<std::monostate>;
 
    [[nodiscard]] static auto wait_for_completion(
        const std::string& job_id,
        std::chrono::milliseconds timeout = std::chrono::minutes{30},
        status_callback callback = nullptr)
        -> Result<inference_status>;
 
    [[nodiscard]] static auto list_active_jobs()
        -> Result<std::vector<inference_status>>;
 
    // =========================================================================
    // Model Management
    // =========================================================================
 
    [[nodiscard]] static auto list_models()
        -> Result<std::vector<model_info>>;
 
    [[nodiscard]] static auto get_model_info(const std::string& model_id)
        -> Result<model_info>;
 
    // =========================================================================
    // Health Check
    // =========================================================================
 
    [[nodiscard]] static auto check_health() -> bool;
 
    [[nodiscard]] static auto get_latency()
        -> std::optional<std::chrono::milliseconds>;
 
    // =========================================================================
    // Configuration
    // =========================================================================
 
    [[nodiscard]] static auto get_config() -> const ai_service_config&;
 
    [[nodiscard]] static auto update_credentials(
        authentication_type auth_type,
        const std::string& credentials)
        -> Result<std::monostate>;
 
private:
    // Prevent instantiation
    ai_service_connector() = delete;
    ~ai_service_connector() = delete;
    ai_service_connector(const ai_service_connector&) = delete;
    ai_service_connector& operator=(const ai_service_connector&) = delete;
 
    // PIMPL implementation
    class impl;
    static std::unique_ptr<impl> pimpl_;
};
 
// =============================================================================
// Helper Functions
// =============================================================================
 
[[nodiscard]] inline auto to_string(inference_status_code status) -> std::string {
    switch (status) {
        case inference_status_code::pending:
            return "pending";
        case inference_status_code::running:
            return "running";
        case inference_status_code::completed:
            return "completed";
        case inference_status_code::failed:
            return "failed";
        case inference_status_code::cancelled:
            return "cancelled";
        case inference_status_code::timeout:
            return "timeout";
        default:
            return "unknown";
    }
}
 
[[nodiscard]] inline auto to_string(authentication_type type) -> std::string {
    switch (type) {
        case authentication_type::none:
            return "none";
        case authentication_type::api_key:
            return "api_key";
        case authentication_type::bearer_token:
            return "bearer_token";
        case authentication_type::basic:
            return "basic";
        default:
            return "unknown";
    }
}
 
}  // namespace kcenon::pacs::ai